package com.wicket.okrcalc.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.integration.dto.*;
import com.wicket.okrcalc.base.service.dto.req.*;
import com.wicket.okrcalc.biz.service.dto.common.UpdateCycleDto;
import com.wicket.okrcalc.biz.service.dto.req.*;
import com.wicket.okrcalc.biz.service.dto.req.AddPlanFinanceMqQueueComReqDto;
import com.wicket.okrcalc.biz.service.dto.req.AddPlanTargetMqQueueComReqDto;
import com.wicket.okrcalc.biz.service.dto.req.CommitToBeReportedTaskStdDataComReqDto;
import com.wicket.okrcalc.biz.service.dto.req.QueryPlanFinanceMqQueueListComReqDto;
import com.wicket.okrcalc.biz.service.dto.req.QueryPlanTargetMqQueueListComReqDto;
import com.wicket.okrcalc.biz.service.dto.req.QueryStandardDataDetailComReqDto;
import com.wicket.okrcalc.biz.service.dto.res.*;
import com.wicket.okrcalc.biz.service.dto.res.AddPlanFinanceMqQueueComRespDto;
import com.wicket.okrcalc.biz.service.dto.res.AddPlanTargetMqQueueComRespDto;
import com.wicket.okrcalc.biz.service.dto.res.CommitToBeReportedTaskStdDataComRespDto;
import com.wicket.okrcalc.biz.service.dto.res.QueryPlanFinanceMqQueueListComRespDto;
import com.wicket.okrcalc.biz.service.dto.res.QueryPlanTargetMqQueueListComRespDto;
import com.wicket.okrcalc.biz.service.dto.res.QueryStandardDataDetailComRespDto;
import com.wicket.okrcalc.common.exception.BizException;
import com.wicket.okrcalc.common.util.CommonFunctionHelper;
import com.wicket.okrcalc.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;

import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrcalc.base.service.MOmsStandardDataResultService;
import com.wicket.okrcalc.common.exception.Assert;
import com.wicket.okrcalc.biz.service.nb.NbEvaCalc;
import com.wicket.okrapp.integration.FwAppTargetCalcClient;

import java.util.Collections;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrcomponent.integration.FwCompBusinessAtomClient;
import com.wicket.okrcomponent.integration.FwCompEvaCalcClient;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrcalc.dal.po.mbg.OmsStandardDataResult;
import com.wicket.okrapp.integration.FwAppTargetCycleClient;
import com.wicket.okrcomponent.integration.FwCompDivineDataClient;
import com.wicket.okrcalc.biz.service.DashboradStandardDataService;
import com.wicket.okrapp.integration.FwAppExecuteCycleClient;
//import com.wicket.okrcalc.biz.service.dto.common.DataSetsListOneDto;
//import com.wicket.okrcalc.biz.service.dto.common.DataSetsListTwoDto;
import com.wicket.okrcalc.biz.service.dto.common.EvaObjTargetCycleDto;
import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrapp.integration.FwAppEvaCalcClient;
import com.wicket.okrcalc.biz.service.CalculationRulesService;
import com.wicket.okrcalc.biz.service.InterfaceModeService;
import com.wicket.okrcalc.base.service.dto.req.QueryStandardDataBaseListReq;
import java.util.ArrayList;
import com.wicket.okrapp.integration.FwAppCycleStageDataClient;
import com.wicket.okrcalc.biz.service.TargetCalcService;
import com.wicket.okrcalc.biz.service.StandardDataService;
import com.wicket.okrcalc.biz.service.dto.common.DataSetsListOneDto;
import com.wicket.okrcalc.biz.service.dto.common.DataSetsListTwoDto;
import com.wicket.okrcalc.biz.service.dto.common.TargetBelongCycleDto;
import com.wicket.okrcalc.biz.service.DivineDataService;
import com.wicket.okrcalc.biz.service.dto.common.FieldDataDto;

/**
 * @author ：
 * @date ：
 *
 * 
 * @version 1.0
 */
@Service
public class EvaCalcServiceImpl
  implements com.wicket.okrcalc.biz.service.EvaCalcService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private MOmsStandardDataResultService mOmsStandardDataResultService;
@Resource
  private NbEvaCalc nbEvaCalc;
@Resource
  private FwAppTargetCalcClient fwAppTargetCalcClient;
//@Resource
 //private undefinedService undefinedService;
//@Resource
 //private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private FwCompBusinessAtomClient fwCompBusinessAtomClient;
@Resource
  private FwCompEvaCalcClient fwCompEvaCalcClient;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private FwAppTargetCycleClient fwAppTargetCycleClient;
@Resource
  private FwCompDivineDataClient fwCompDivineDataClient;
@Resource
  private DashboradStandardDataService dashboradStandardDataService;
@Resource
  private FwAppExecuteCycleClient fwAppExecuteCycleClient;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  private FwAppEvaCalcClient fwAppEvaCalcClient;
//@Resource
 //private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
//@Resource
 //private MCustomFields5Service mCustomFields5Service;
@Resource
  private CalculationRulesService calculationRulesService;
@Resource
  private InterfaceModeService interfaceModeService;
@Resource
  private FwAppCycleStageDataClient fwAppCycleStageDataClient;
@Resource
  private TargetCalcService targetCalcService;
@Resource
  private StandardDataService standardDataService;
@Resource
  private DivineDataService divineDataService;
/**
   * D4规划树执行计算公式(公共)[9684]
   * gen by moon at 5/30/2024, 11:10:53 PM
   */
  @Trace(operationName = "D4规划树执行计算公式(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementPlanTreeExecutesCalcFormulaComRespDto implementPlanTreeExecutesCalcFormulaCom(ImplementPlanTreeExecutesCalcFormulaComReqDto reqDto){
    
      
      //步骤0: M4执行第九接收字段（特殊方法） - implementNineReceivingField
     //ModelCode: receptionService
        ImplementNineReceivingFieldRespDto receptionServiceRes = null;
    ImplementNineReceivingFieldReqDto receptionServiceReq=new ImplementNineReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1829331_1
receptionServiceReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1829332_1
receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1829323_1
receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1829324_1
receptionServiceReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1829335_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1829325_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1829326_1
    }
  
    /*M4接收入参字段[8708]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCycleStartTime(),"D4规划树执行计算公式(公共)-M4接收入参字段-周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq.getCycleEndTime(),"D4规划树执行计算公式(公共)-M4接收入参字段-周期结束时间不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjEntityId(),"D4规划树执行计算公式(公共)-M4接收入参字段-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTypeCode(),"D4规划树执行计算公式(公共)-M4接收入参字段-主树被评对象类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getBelongToContentId(),"D4规划树执行计算公式(公共)-M4接收入参字段-数据归属内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D4规划树执行计算公式(公共)-M4接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D4规划树执行计算公式(公共)-M4接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementNineReceivingField(receptionServiceReq);
      
      
      
    
//步骤1: D3查询目标归属周期（双排序）列表(公共) - queryTargetBelongCycleBySortListCom
     QueryTargetBelongCycleBySortListComRespDto queryTargetBelongCycleBySortListComRespDto = null;
    QueryTargetBelongCycleBySortListComReqDto queryTargetBelongCycleBySortListComReqDto=new QueryTargetBelongCycleBySortListComReqDto();
  if(reqDto!=null){
      queryTargetBelongCycleBySortListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1829130_1
queryTargetBelongCycleBySortListComReqDto.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1829131_1
queryTargetBelongCycleBySortListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1829136_1
queryTargetBelongCycleBySortListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1829135_1
queryTargetBelongCycleBySortListComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1829137_1
queryTargetBelongCycleBySortListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1829132_1
queryTargetBelongCycleBySortListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1829133_1
    }
  
    /*D3查询目标归属周期（双排序）列表(公共)[8733]   */
    Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getCycleStartTime(),"D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-周期开始时间不能为空",false);
Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getCycleEndTime(),"D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-周期结束时间不能为空",false);
Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getEvaObjEntityId(),"D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getEvaObjTypeCode(),"D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-主树被评对象类型编码不能为空",false);
Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getBelongToContentId(),"D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getEvaluationTemplateId(),"D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getSpaceId(),"D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-创建于空间ID不能为空",false);
      queryTargetBelongCycleBySortListComRespDto = fwAppTargetCalcClient.queryTargetBelongCycleBySortListCom(queryTargetBelongCycleBySortListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
ImplementPlanTreeExecutesCalcFormulaComRespDto retData = new ImplementPlanTreeExecutesCalcFormulaComRespDto();
  
  

  
  
return retData;
  }
/**
   * D4执行分段查询目标父周期(公共)[9681]
   * gen by moon at 5/30/2024, 11:33:16 PM
   */
  @Trace(operationName = "D4执行分段查询目标父周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSegQueryTargetCycleComRespDto implementSegQueryTargetCycleCom(ImplementSegQueryTargetCycleComReqDto reqDto){
    
      
      //virtualUsage M4约定业务数据对象等  69378
      //ModelCode: receptionService
        ImplementNineReceivingFieldRespDto receptionServiceRes = null;
    ImplementNineReceivingFieldReqDto receptionServiceReq=new ImplementNineReceivingFieldReqDto();
  receptionServiceReq.setBusinessDataSetTableName("oms_evaluation_object_target_cycle");//CUSTOM_CONVENTION//sourceId:1829097_1_69378
receptionServiceReq.setRedisDataObjectCatalogue("分段查询临时记录");//sourceId:1829098_1_69378
  
    /*M4约定业务数据对象等[8708]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getBusinessDataSetTableName(),"D4执行分段查询目标父周期(公共)-M4约定业务数据对象等-业务数据对象表名不能为空",false);
Assert.isNull(receptionServiceReq.getRedisDataObjectCatalogue(),"D4执行分段查询目标父周期(公共)-M4约定业务数据对象等-Redis数据对象目录不能为空",false);
      receptionServiceRes = nbEvaCalc.implementNineReceivingField(receptionServiceReq);
      
      
      
//virtualUsage M4计算死循环（特殊方法）  69379
      //ModelCode: endlessLoop
      // TODO: 2024/5/31
      while(true) {


//virtualUsage D2查Redis中上一批次数据集最后一条记录（业务原子）  69380
          QueryRedisBusinessDataSetDetailComRespDto queryRedisBusinessDataSetDetailComRespDto = null;
          QueryRedisBusinessDataSetDetailComReqDto queryRedisBusinessDataSetDetailComReqDto = new QueryRedisBusinessDataSetDetailComReqDto();
          if (receptionServiceRes != null) {
              queryRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1829099_1_69380
              queryRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1829101_1_69380
          }
          if (reqDto != null) {
              queryRedisBusinessDataSetDetailComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1829100_1_69380
          }

          /*D2查Redis中上一批次数据集最后一条记录（业务原子）[8411]   */
          Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D4执行分段查询目标父周期(公共)-D2查Redis中上一批次数据集最后一条记录（业务原子）-业务数据对象不能为空", false);
          Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D4执行分段查询目标父周期(公共)-D2查Redis中上一批次数据集最后一条记录（业务原子）-Redis数据对象目录不能为空", false);
          Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getDataObjectBatchCode(), "D4执行分段查询目标父周期(公共)-D2查Redis中上一批次数据集最后一条记录（业务原子）-数据对象批次标识不能为空", false);
          queryRedisBusinessDataSetDetailComRespDto = fwCompBusinessAtomClient.queryRedisBusinessDataSetDetailCom(queryRedisBusinessDataSetDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D3分段查询目标内容目标周期(公共)  69381
          ImplementSubsectionQueryTargetContCycleComRespDto implementSubsectionQueryTargetContCycleComRespDto = null;
          if (queryRedisBusinessDataSetDetailComRespDto != null) {
              ImplementSubsectionQueryTargetContCycleComReqDto implementSubsectionQueryTargetContCycleComReqDto = new ImplementSubsectionQueryTargetContCycleComReqDto();
              implementSubsectionQueryTargetContCycleComReqDto.setDatasNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1827810_1_69381
              implementSubsectionQueryTargetContCycleComReqDto.setOrderFieldName("evaObjTargetCycleCode");//CUSTOM_CONVENTION//sourceId:1827811_1_69381
              implementSubsectionQueryTargetContCycleComReqDto.setOrderRule("FROM_LARGE_TO_SMALL");//sourceId:1827812_1_69381
              implementSubsectionQueryTargetContCycleComReqDto.setBusinessDataSetPrimaryKeyName("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:1827813_1_69381
              implementSubsectionQueryTargetContCycleComReqDto.setIsParentCycle("TRUE");//CUSTOM_CONVENTION//sourceId:1829103_1_69381
              implementSubsectionQueryTargetContCycleComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//CUSTOM_CONVENTION//sourceId:1829104_1_69381
              if (receptionServiceRes != null) {
                  implementSubsectionQueryTargetContCycleComReqDto.setBusinessDataSetTableName(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1827809_1_69381
              }
              if (queryRedisBusinessDataSetDetailComRespDto != null) {
                  implementSubsectionQueryTargetContCycleComReqDto.setLastDataObjectId(queryRedisBusinessDataSetDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1827814_1_69381
              }
              if (reqDto != null) {
                  implementSubsectionQueryTargetContCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1827815_1_69381
                  implementSubsectionQueryTargetContCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1827816_1_69381
              }

              /*D3分段查询目标内容目标周期(公共)[9663]   */
              Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getBusinessDataSetTableName(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-业务数据对象表名不能为空", false);
              Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getDatasNum(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-数据条数不能为空", false);
              Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getOrderFieldName(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-排序字段名不能为空", false);
              Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getOrderRule(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-排序规则不能为空", false);
              Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getBusinessDataSetPrimaryKeyName(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-业务数据对象主键名不能为空", false);
              Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getEvaObjEntityId(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-被评对象内容表主键ID不能为空", false);
              Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getEvaObjTypeCode(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-被评对象类型编码不能为空", false);
              Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getIsParentCycle(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-是否父周期不能为空", false);
              Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getEvaluationTemplateId(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-评价模板ID不能为空", false);
              Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getSubjectLifeCycle(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-主体生命周期不能为空", false);
              implementSubsectionQueryTargetContCycleComRespDto = fwAppTargetCalcClient.implementSubsectionQueryTargetContCycleCom(implementSubsectionQueryTargetContCycleComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


          }
          if ((implementSubsectionQueryTargetContCycleComRespDto != null && implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList() != null && implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList().size() > 0)) {
              //if(D3分段查询目标内容目标周期(公共).被评对象目标周期列表数据集条数 大于 0)  69382

              RefreshSegQueryRedisRecordComRespDto refreshSegQueryRedisRecordComRespDto = null;
              if (implementSubsectionQueryTargetContCycleComRespDto != null && queryRedisBusinessDataSetDetailComRespDto != null) {
                  RefreshSegQueryRedisRecordComReqDto refreshSegQueryRedisRecordComReqDto = new RefreshSegQueryRedisRecordComReqDto();
                  refreshSegQueryRedisRecordComReqDto.setBusinessDataSetPrimaryKeyName("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:1828720_1_69386
                  if (implementSubsectionQueryTargetContCycleComRespDto != null && implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList() != null && !CollectionUtil.isEmpty(implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList())) {
                      refreshSegQueryRedisRecordComReqDto.setBusinessDataSetList(implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList().stream().map(item -> String.valueOf(item.getEvaObjTargetCycleId()))
                              .collect(Collectors.toList()));/*list-to-strings*///sourceId:1828715_1_69386
                  }
                  if (receptionServiceRes != null) {
                      refreshSegQueryRedisRecordComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1828716_1_69386
                      refreshSegQueryRedisRecordComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1828717_1_69386
                  }
                  if (reqDto != null) {
                      refreshSegQueryRedisRecordComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1828718_1_69386
                  }
                  if (queryRedisBusinessDataSetDetailComRespDto != null) {
                      refreshSegQueryRedisRecordComReqDto.setLastDataObjectId(queryRedisBusinessDataSetDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1828719_1_69386
                  }

                  /*D2更新分段查询Redis记录(公共)[9679]   */
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getBusinessDataObject(), "D4执行分段查询目标父周期(公共)-D2更新分段查询Redis记录(公共)-业务数据对象不能为空", false);
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getRedisDataObjectCatalogue(), "D4执行分段查询目标父周期(公共)-D2更新分段查询Redis记录(公共)-Redis数据对象目录不能为空", false);
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getDataObjectBatchCode(), "D4执行分段查询目标父周期(公共)-D2更新分段查询Redis记录(公共)-数据对象批次标识不能为空", false);
                  Assert.isNull(refreshSegQueryRedisRecordComReqDto.getBusinessDataSetPrimaryKeyName(), "D4执行分段查询目标父周期(公共)-D2更新分段查询Redis记录(公共)-业务数据对象主键名不能为空", false);
                  refreshSegQueryRedisRecordComRespDto = fwCompEvaCalcClient.refreshSegQueryRedisRecordCom(refreshSegQueryRedisRecordComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


              }
//ModelCode: circulationCollections
              for (com.wicket.okrapp.integration.dto.EvaObjTargetCycleDto circulationCollectionsRes : implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList()) {

//ModelCode: circulationEnd
              }

          } else if ((implementSubsectionQueryTargetContCycleComRespDto != null && implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList() != null && implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList().size() == 0)) {
              //elseif(D3分段查询目标内容目标周期(公共).被评对象目标周期列表数据集条数 等于 0)  69383

              DeleteRedisBusinessDataComRespDto deleteRedisBusinessDataComRespDto = null;
              DeleteRedisBusinessDataComReqDto deleteRedisBusinessDataComReqDto = new DeleteRedisBusinessDataComReqDto();
              deleteRedisBusinessDataComReqDto.setIsDataList("FALSE");//sourceId:1828610_1_69384
              if (receptionServiceRes != null) {
                  deleteRedisBusinessDataComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1828607_1_69384
                  deleteRedisBusinessDataComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1828611_1_69384
              }
              if (reqDto != null) {
                  deleteRedisBusinessDataComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1828609_1_69384
              }

              /*D2-删除redis业务数据对象(公共)[8397]   */
              Assert.isNull(deleteRedisBusinessDataComReqDto.getBusinessDataObject(), "D4执行分段查询目标父周期(公共)-D2-删除redis业务数据对象(公共)-业务数据对象不能为空", false);
              Assert.isNull(deleteRedisBusinessDataComReqDto.getRedisDataObjectCatalogue(), "D4执行分段查询目标父周期(公共)-D2-删除redis业务数据对象(公共)-Redis数据对象目录不能为空", false);
              Assert.isNull(deleteRedisBusinessDataComReqDto.getDataObjectBatchCode(), "D4执行分段查询目标父周期(公共)-D2-删除redis业务数据对象(公共)-数据对象批次标识不能为空", false);
              Assert.isNull(deleteRedisBusinessDataComReqDto.getIsDataList(), "D4执行分段查询目标父周期(公共)-D2-删除redis业务数据对象(公共)-是否是数据集对象不能为空", false);
              deleteRedisBusinessDataComRespDto = fwCompInterfaceModeClient.deleteRedisBusinessDataCom(deleteRedisBusinessDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: end
              // TODO: 2024/5/31
              break;


          }
      }
ImplementSegQueryTargetCycleComRespDto retData = new ImplementSegQueryTargetCycleComRespDto();
  
  

  
  
return retData;
  }
/**
   * D4查询标准数据(开始时间小于结束时间大于等于)详情[9804]
   * gen by moon at 6/14/2024, 6:49:23 PM
   */
  @Trace(operationName = "D4查询标准数据(开始时间小于结束时间大于等于)详情")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryStandardDataStartLessEndBigEqualDetailComRespDto queryStandardDataStartLessEndBigEqualDetailCom(QueryStandardDataStartLessEndBigEqualDetailComReqDto reqDto){


      OmsStandardDataResult omsStandardDataResult_1 =null;
//步骤0: 4-1-01查询标准数据(开始时间小于结束时间大于等于)详情 - queryStandardDataStartLessEndBigEqualDetail
     OmsStandardDataResult omsStandardDataResult = null;
    QueryStandardDataStartLessEndBigEqualDetailReq queryStandardDataStartLessEndBigEqualDetailReq=new QueryStandardDataStartLessEndBigEqualDetailReq();
  if(reqDto!=null){
      queryStandardDataStartLessEndBigEqualDetailReq.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1865538_1
queryStandardDataStartLessEndBigEqualDetailReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1865541_1
queryStandardDataStartLessEndBigEqualDetailReq.setIsNewData(reqDto.getIsNewData());//SimpleFieldAssign//sourceId:1865542_1
queryStandardDataStartLessEndBigEqualDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1865539_1
queryStandardDataStartLessEndBigEqualDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1865540_1
queryStandardDataStartLessEndBigEqualDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1865544_1
queryStandardDataStartLessEndBigEqualDetailReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1865545_1
queryStandardDataStartLessEndBigEqualDetailReq.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1865543_1
queryStandardDataStartLessEndBigEqualDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1865546_1
queryStandardDataStartLessEndBigEqualDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1865547_1
    }

    /*4-1-01查询标准数据(开始时间小于结束时间大于等于)详情[9803]   */
    Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getDataType(),"D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-数据点类型不能为空",false);
Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getParentSubMidCycleType(),"D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-父子中周期类型不能为空",false);
Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getIsNewData(),"D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-是否归属周期最新数据不能为空",false);
Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getCycleStartTime(),"D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-周期开始时间不能为空",false);
Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getCycleEndTime(),"D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-周期结束时间不能为空",false);
Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getCycleTypeCode(),"D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-周期类型标识不能为空",false);
Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getBelongToContentId(),"D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-数据归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getExtendedField3(),"D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-扩展字段3不能为空",false);
Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getThemeContentId(),"D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getSubjectLifeCycle(),"D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-主体生命周期不能为空",false);
      omsStandardDataResult = mOmsStandardDataResultService.queryStandardDataStartLessEndBigEqualDetail(queryStandardDataStartLessEndBigEqualDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsStandardDataResult_1 = omsStandardDataResult;

QueryStandardDataStartLessEndBigEqualDetailComRespDto retData = new QueryStandardDataStartLessEndBigEqualDetailComRespDto();
  if(omsStandardDataResult_1!=null){
      retData.setDataResultId(omsStandardDataResult_1.getDataResultId());//SimpleFieldAssign//sourceId:1865560_1
retData.setDataResult(omsStandardDataResult_1.getDataResult());//SimpleFieldAssign//sourceId:1865561_1
    }




return retData;
  }
/**
   * D4分析历史与当前工作周期标准数据(公共)[9848]
   * gen by moon at 6/23/2024, 9:04:18 PM
   */
  @Trace(operationName = "D4分析历史与当前工作周期标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisHistoryAndCurWorkCycleStandDardComRespDto analysisHistoryAndCurWorkCycleStandDardCom(AnalysisHistoryAndCurWorkCycleStandDardComReqDto reqDto){


      //virtualUsage M4约定当前系统时间  70615
      //ModelCode: receptionService
        ImplementCalcReceivingField003RespDto receptionServiceRes = null;
    ImplementCalcReceivingField003ReqDto receptionServiceReq=new ImplementCalcReceivingField003ReqDto();
  receptionServiceReq.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1887224_1_70615

    /*M4约定当前系统时间[9537]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getComTimeField(),"D4分析历史与当前工作周期标准数据(公共)-M4约定当前系统时间-通用时间字段不能为空",false);
      receptionServiceRes = nbEvaCalc.implementCalcReceivingField003(receptionServiceReq);



//virtualUsage D2-3查配置项匹配答案详情(公共)（跨服务）  70708
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1889475_1_70708
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("CYCLE_MODE");//CUSTOM_CONVENTION//sourceId:1889476_1_70708
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1889477_1_70708
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1889474_1_70708
    }

    /*D2-3查配置项匹配答案详情(公共)（跨服务）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D4分析历史与当前工作周期标准数据(公共)-D2-3查配置项匹配答案详情(公共)（跨服务）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D4分析历史与当前工作周期标准数据(公共)-D2-3查配置项匹配答案详情(公共)（跨服务）-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D4分析历史与当前工作周期标准数据(公共)-D2-3查配置项匹配答案详情(公共)（跨服务）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D4分析历史与当前工作周期标准数据(公共)-D2-3查配置项匹配答案详情(公共)（跨服务）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）  70612
      QueryEvaObjTargetCycleByCycleTimeListComRespDto queryEvaObjTargetCycleByCycleTimeListComRespDto = null;
    QueryEvaObjTargetCycleByCycleTimeListComReqDto queryEvaObjTargetCycleByCycleTimeListComReqDto=new QueryEvaObjTargetCycleByCycleTimeListComReqDto();
  queryEvaObjTargetCycleByCycleTimeListComReqDto.setTargetCycleContentTypeCode("TARGET");//sourceId:1889422_1_70612
  queryEvaObjTargetCycleByCycleTimeListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1887218_1_70612
if(reqDto!=null){
      queryEvaObjTargetCycleByCycleTimeListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1887215_1_70612
queryEvaObjTargetCycleByCycleTimeListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1887216_1_70612
queryEvaObjTargetCycleByCycleTimeListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887217_1_70612
    }

    /*D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）[7720]   */
    Assert.isNull(queryEvaObjTargetCycleByCycleTimeListComReqDto.getEvaObjEntityId(),"D4分析历史与当前工作周期标准数据(公共)-D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleByCycleTimeListComReqDto.getEvaObjTypeCode(),"D4分析历史与当前工作周期标准数据(公共)-D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleByCycleTimeListComReqDto.getTargetCycleContentTypeCode(),"D4分析历史与当前工作周期标准数据(公共)-D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleByCycleTimeListComReqDto.getEvaluationTemplateId(),"D4分析历史与当前工作周期标准数据(公共)-D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleByCycleTimeListComReqDto.getSubjectLifeCycle(),"D4分析历史与当前工作周期标准数据(公共)-D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）-主体生命周期不能为空",false);
      queryEvaObjTargetCycleByCycleTimeListComRespDto = fwAppTargetCycleClient.queryEvaObjTargetCycleByCycleTimeListCom(queryEvaObjTargetCycleByCycleTimeListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage M4-执行目标周期循环开始【特殊方法】  70613
      //ModelCode: circulationCollections
        for (com.wicket.okrapp.integration.dto.EvaObjTargetCycleDto circulationCollectionsRes: queryEvaObjTargetCycleByCycleTimeListComRespDto.getEvaObjTargetCycleList()){

//virtualUsage D3分析目标父子中周期类型(公共)  70707
      AnalysisTargetParentSubMidCycleTypeComRespDto analysisTargetParentSubMidCycleTypeComRespDto = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null){
          AnalysisTargetParentSubMidCycleTypeComReqDto analysisTargetParentSubMidCycleTypeComReqDto=new AnalysisTargetParentSubMidCycleTypeComReqDto();
  if(queryConfItemMatchAnswerDetailComRespDto!=null){
      analysisTargetParentSubMidCycleTypeComReqDto.setPeriodicModeTypeCode(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1889443_1_70707
    }
if(circulationCollectionsRes!=null){
      analysisTargetParentSubMidCycleTypeComReqDto.setIsParentCycle(circulationCollectionsRes.getIsParentCycle()!=null?String.valueOf(circulationCollectionsRes.getIsParentCycle()):"");//SimpleFieldAssign//sourceId:1889445_1_70707
analysisTargetParentSubMidCycleTypeComReqDto.setIsMetaphase(circulationCollectionsRes.getIsMetaphase()!=null?String.valueOf(circulationCollectionsRes.getIsMetaphase()):"");//SimpleFieldAssign//sourceId:1889446_1_70707
analysisTargetParentSubMidCycleTypeComReqDto.setIsSubCycle(circulationCollectionsRes.getIsSubCycle()!=null?String.valueOf(circulationCollectionsRes.getIsSubCycle()):"");//SimpleFieldAssign//sourceId:1889444_1_70707
    }

    /*D3分析目标父子中周期类型(公共)[9842]   */
    Assert.isNull(analysisTargetParentSubMidCycleTypeComReqDto.getPeriodicModeTypeCode(),"D4分析历史与当前工作周期标准数据(公共)-D3分析目标父子中周期类型(公共)-周期模式类型编码不能为空",false);
Assert.isNull(analysisTargetParentSubMidCycleTypeComReqDto.getIsParentCycle(),"D4分析历史与当前工作周期标准数据(公共)-D3分析目标父子中周期类型(公共)-是否父周期不能为空",false);
Assert.isNull(analysisTargetParentSubMidCycleTypeComReqDto.getIsMetaphase(),"D4分析历史与当前工作周期标准数据(公共)-D3分析目标父子中周期类型(公共)-是否中期不能为空",false);
Assert.isNull(analysisTargetParentSubMidCycleTypeComReqDto.getIsSubCycle(),"D4分析历史与当前工作周期标准数据(公共)-D3分析目标父子中周期类型(公共)-是否子周期不能为空",false);
      analysisTargetParentSubMidCycleTypeComRespDto = fwAppEvaCalcClient.analysisTargetParentSubMidCycleTypeCom(analysisTargetParentSubMidCycleTypeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D2两个时间对比大小(公共)  70621
      CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  if(receptionServiceRes!=null){
      checkTimeScopeSearchComReqDto.setCurrentTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1887230_1_70621
    }
if(circulationCollectionsRes!=null){
      checkTimeScopeSearchComReqDto.setCompareTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1887232_1_70621
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D4分析历史与当前工作周期标准数据(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D4分析历史与当前工作周期标准数据(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))) {
        //if(D2当前系统时间与目标计划结束时间对比.时间比较结果 等于 之后（大于）)  70622

ImplementUpdateCycleStatisticsDataComRespDto implementUpdateCycleStatisticsDataComRespDto = null;
    if(analysisTargetParentSubMidCycleTypeComRespDto !=null){
    ImplementUpdateCycleStatisticsDataComReqDto implementUpdateCycleStatisticsDataComReqDto=new ImplementUpdateCycleStatisticsDataComReqDto();
  implementUpdateCycleStatisticsDataComReqDto.setUpdateDataCycleSceneType("HISTORY_WORK_CYCLE");//sourceId:1887578_1_70665
if(reqDto!=null){
      implementUpdateCycleStatisticsDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1889433_1_70665
implementUpdateCycleStatisticsDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1889434_1_70665
      implementUpdateCycleStatisticsDataComReqDto.setIsForceStaticHistoryData(reqDto.getIsForceStaticHistoryData());//SimpleFieldAssign//sourceId:1887579_1_70665
implementUpdateCycleStatisticsDataComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1887580_1_70665
implementUpdateCycleStatisticsDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887584_1_70665
implementUpdateCycleStatisticsDataComReqDto.setEvaluationTemplateTypeCode(reqDto.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:1889436_1_70665
implementUpdateCycleStatisticsDataComReqDto.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1889437_1_70665
implementUpdateCycleStatisticsDataComReqDto.setHighestOrgID(reqDto.getHighestOrgID());//SimpleFieldAssign//sourceId:1889438_1_70665
implementUpdateCycleStatisticsDataComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1889439_1_70665
implementUpdateCycleStatisticsDataComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1889440_1_70665
implementUpdateCycleStatisticsDataComReqDto.setDecimalPointRules(reqDto.getDecimalPointRules());//SimpleFieldAssign//sourceId:1889441_1_70665
implementUpdateCycleStatisticsDataComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1889442_1_70665
    }
if(circulationCollectionsRes!=null){
      implementUpdateCycleStatisticsDataComReqDto.setTargetCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1890035_1_70665
      implementUpdateCycleStatisticsDataComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887583_1_70665
implementUpdateCycleStatisticsDataComReqDto.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1887581_1_70665
implementUpdateCycleStatisticsDataComReqDto.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1887582_1_70665
    }
if(analysisTargetParentSubMidCycleTypeComRespDto!=null){
      implementUpdateCycleStatisticsDataComReqDto.setParentSubMidCycleType(analysisTargetParentSubMidCycleTypeComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1889435_1_70665
    }

    /*D4执行历史工作周期的统计数据(公共)[9853]   */
    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getEventBatchUpdateCode(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getCalcStartTime(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-计算开始时间不能为空",false);
    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getUpdateDataCycleSceneType(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-数据更新周期场景类型不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getIsForceStaticHistoryData(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-是否强制统计历史数据不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getUpdateCycleTypeCode(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getTargetCycleId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-目标周期ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getEvaObjTargetCycleId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getParentSubMidCycleType(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getCycleStartTime(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-目标计划开始时间不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getCycleEndTime(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-目标计划结束时间不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getEvaluationTemplateId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getEvaluationTemplateTypeCode(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-冗余评价模板类型配置项不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getOperationInductionId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-操作人就职记录ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getHighestOrgID(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-最高组织ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getSpaceId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getAppId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-创建于联盟应用ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getDecimalPointRules(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-小数点规则不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getDecimalDigitsLastRules(),"D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-小数最后一位规则不能为空",false);
      implementUpdateCycleStatisticsDataComRespDto = dashboradStandardDataService.implementUpdateCycleStatisticsDataCom(implementUpdateCycleStatisticsDataComReqDto)/*vcase invoke isSameApp*/;



           }
      }
else if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("BEFORE")||checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))){
       //elseif((D2当前系统时间与目标计划结束时间对比.时间比较结果 等于 之前（小于） or D2当前系统时间与目标计划结束时间对比.时间比较结果 等于 当前（等于）))  70623

ImplementUpdateCycleStatisticsDataComRespDto implementUpdateCycleStatisticsDataComRespDto_1 = null;
    if(analysisTargetParentSubMidCycleTypeComRespDto !=null){
    ImplementUpdateCycleStatisticsDataComReqDto implementUpdateCycleStatisticsDataComReqDto_1=new ImplementUpdateCycleStatisticsDataComReqDto();
  implementUpdateCycleStatisticsDataComReqDto_1.setUpdateDataCycleSceneType("CUR_WORK_CYCLE");//sourceId:1887573_1_70667
if(reqDto!=null){
      implementUpdateCycleStatisticsDataComReqDto_1.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1889423_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1889424_1_70667
      implementUpdateCycleStatisticsDataComReqDto_1.setIsForceStaticHistoryData(reqDto.getIsForceStaticHistoryData());//SimpleFieldAssign//sourceId:1887574_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1887575_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887572_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setEvaluationTemplateTypeCode(reqDto.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:1889431_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1889425_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setHighestOrgID(reqDto.getHighestOrgID());//SimpleFieldAssign//sourceId:1889426_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1889427_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1889428_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setDecimalPointRules(reqDto.getDecimalPointRules());//SimpleFieldAssign//sourceId:1889429_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1889430_1_70667
    }
if(circulationCollectionsRes!=null){
      implementUpdateCycleStatisticsDataComReqDto_1.setTargetCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1890088_1_70667
      implementUpdateCycleStatisticsDataComReqDto_1.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887571_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1887576_1_70667
implementUpdateCycleStatisticsDataComReqDto_1.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1887577_1_70667
    }
if(analysisTargetParentSubMidCycleTypeComRespDto!=null){
      implementUpdateCycleStatisticsDataComReqDto_1.setParentSubMidCycleType(analysisTargetParentSubMidCycleTypeComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1889432_1_70667
    }

    /*D4执行当前工作周期的统计数据(公共)[9853]   */
    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getEventBatchUpdateCode(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getCalcStartTime(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-计算开始时间不能为空",false);
    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getUpdateDataCycleSceneType(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-数据更新周期场景类型不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getIsForceStaticHistoryData(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-是否强制统计历史数据不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getUpdateCycleTypeCode(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getTargetCycleId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-目标周期ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getEvaObjTargetCycleId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getParentSubMidCycleType(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getCycleStartTime(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-目标计划开始时间不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getCycleEndTime(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-目标计划结束时间不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getEvaluationTemplateId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getEvaluationTemplateTypeCode(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-冗余评价模板类型配置项不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getOperationInductionId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-操作人就职记录ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getHighestOrgID(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-最高组织ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getSpaceId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getAppId(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-创建于联盟应用ID不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getDecimalPointRules(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-小数点规则不能为空",false);
Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getDecimalDigitsLastRules(),"D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-小数最后一位规则不能为空",false);
      implementUpdateCycleStatisticsDataComRespDto_1 = dashboradStandardDataService.implementUpdateCycleStatisticsDataCom(implementUpdateCycleStatisticsDataComReqDto_1)/*vcase invoke isSameApp*/;



           }
    }
//virtualUsage M4-执行【循环结束】  70614
      //ModelCode: circulationEnd
        }

AnalysisHistoryAndCurWorkCycleStandDardComRespDto retData = new AnalysisHistoryAndCurWorkCycleStandDardComRespDto();





return retData;
  }
/**
   * D4分析历史与当前更新周期(公共)[9849]
   * gen by moon at 9/15/2024, 11:26:36 PM
   */
  @Trace(operationName = "D4分析历史与当前更新周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisHistoryAndCurUpdateCycleComRespDto analysisHistoryAndCurUpdateCycleCom(AnalysisHistoryAndCurUpdateCycleComReqDto reqDto){


      ImplementCalcReceivingField003RespDto receptionServiceRes_3 =null;
//virtualUsage M4约定系统当前时间  70626
      //ModelCode: receptionService
        ImplementCalcReceivingField003RespDto receptionServiceRes = null;
    ImplementCalcReceivingField003ReqDto receptionServiceReq=new ImplementCalcReceivingField003ReqDto();
  receptionServiceReq.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1887388_1_70626

    /*M4约定系统当前时间[9537]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getComTimeField(),"D4分析历史与当前更新周期(公共)-M4约定系统当前时间-通用时间字段不能为空",false);
      receptionServiceRes = nbEvaCalc.implementCalcReceivingField003(receptionServiceReq);



if((reqDto!= null&&  reqDto.getUpdateDataCycleSceneType() !=null && reqDto.getUpdateDataCycleSceneType().equals("HISTORY_WORK_CYCLE"))) {
        //if(D4分析历史与当前更新周期(公共).数据更新周期场景类型 等于 历史工作周期)  70628

QueryExecuteCycleByEvaTempListComRespDto queryExecuteCycleByEvaTempListComRespDto = null;
    QueryExecuteCycleByEvaTempListComReqDto queryExecuteCycleByEvaTempListComReqDto=new QueryExecuteCycleByEvaTempListComReqDto();
  queryExecuteCycleByEvaTempListComReqDto.setRelateContentTypeCode("TARGET");//sourceId:1925277_1_70661
  queryExecuteCycleByEvaTempListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1887542_1_70661
    queryExecuteCycleByEvaTempListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1887543_1_70661
if(reqDto!=null){
      queryExecuteCycleByEvaTempListComReqDto.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1887544_1_70661
queryExecuteCycleByEvaTempListComReqDto.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1887540_1_70661
queryExecuteCycleByEvaTempListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887541_1_70661
    }

    /*D3查询执行周期阶段列表(公共)[9854]   */
    Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getCycleTypeCode(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表(公共)-周期类型标识不能为空",false);
Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getRelateContentTypeCode(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getSubjectLifeCycle(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表(公共)-主体生命周期不能为空",false);
Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getSpaceId(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表(公共)-创建于空间ID不能为空",false);
      queryExecuteCycleByEvaTempListComRespDto = fwAppExecuteCycleClient.queryExecuteCycleByEvaTempListCom(queryExecuteCycleByEvaTempListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//ModelCode: receptionService
        ImplementCalcReceivingField003RespDto receptionServiceRes_2 = null;
    if(queryExecuteCycleByEvaTempListComRespDto !=null){
          ImplementCalcReceivingField003ReqDto receptionServiceReq_1=new ImplementCalcReceivingField003ReqDto();
  if(queryExecuteCycleByEvaTempListComRespDto!= null&&  queryExecuteCycleByEvaTempListComRespDto.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(queryExecuteCycleByEvaTempListComRespDto.getExecuteCycleStageList())){
      receptionServiceReq_1.setUpdateCycleList(//objList-to-objLists
        queryExecuteCycleByEvaTempListComRespDto.getExecuteCycleStageList().stream().map(item -> {
      UpdateCycleDto elm = new UpdateCycleDto();
      if(item!=null){
      elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:390864_2_70651
elm.setUpdateCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:379010_2_70651
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887433_1_70651
    }

    /*M4接收出参：更新周期ID列表[9537]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbEvaCalc.implementCalcReceivingField003(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
           }
      }
else if((reqDto!= null&&  reqDto.getUpdateDataCycleSceneType() !=null && reqDto.getUpdateDataCycleSceneType().equals("CUR_WORK_CYCLE"))){
       //elseif(D4分析历史与当前更新周期(公共).数据更新周期场景类型 等于 当前工作周期)  70639

QueryExecuteCycleBigStartLessEndListComRespDto queryExecuteCycleBigStartLessEndListComRespDto = null;
    QueryExecuteCycleBigStartLessEndListComReqDto queryExecuteCycleBigStartLessEndListComReqDto=new QueryExecuteCycleBigStartLessEndListComReqDto();
  queryExecuteCycleBigStartLessEndListComReqDto.setRelateContentTypeCode("TARGET");//sourceId:1925280_1_70640
  queryExecuteCycleBigStartLessEndListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1889575_1_70640
  if(reqDto!=null){
      queryExecuteCycleBigStartLessEndListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1887312_1_70640
queryExecuteCycleBigStartLessEndListComReqDto.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1887314_1_70640
queryExecuteCycleBigStartLessEndListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887316_1_70640
    }
if(receptionServiceRes!=null){
      queryExecuteCycleBigStartLessEndListComReqDto.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1887313_1_70640
    }

    /*D3查询执行周期阶段列表（开始大于等于&结束小于等于）[9850]   */
    Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getCycleStartTime(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getCycleEndTime(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getCycleTypeCode(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-周期类型标识不能为空",false);
Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getRelateContentTypeCode(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getEvaluationTemplateId(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getSubjectLifeCycle(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-主体生命周期不能为空",false);
      queryExecuteCycleBigStartLessEndListComRespDto = fwAppExecuteCycleClient.queryExecuteCycleBigStartLessEndListCom(queryExecuteCycleBigStartLessEndListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



QueryExecuteCycleLessStartBIgEndListComRespDto queryExecuteCycleLessStartBIgEndListComRespDto = null;
    QueryExecuteCycleLessStartBIgEndListComReqDto queryExecuteCycleLessStartBIgEndListComReqDto=new QueryExecuteCycleLessStartBIgEndListComReqDto();
  queryExecuteCycleLessStartBIgEndListComReqDto.setRelateContentTypeCode("TARGET");//sourceId:1925284_1_70646
  queryExecuteCycleLessStartBIgEndListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1887372_1_70646
if(receptionServiceRes!=null){
      queryExecuteCycleLessStartBIgEndListComReqDto.setCycleStartTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1887369_1_70646
queryExecuteCycleLessStartBIgEndListComReqDto.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1887370_1_70646
    }
if(reqDto!=null){
queryExecuteCycleLessStartBIgEndListComReqDto.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1887436_1_70646
queryExecuteCycleLessStartBIgEndListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887371_1_70646
    }

    /*D3查询执行周期阶段列表（开始小于等于&结束大于等于）[9851]   */
    Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getCycleStartTime(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getCycleEndTime(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getCycleTypeCode(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-周期类型标识不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getRelateContentTypeCode(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getEvaluationTemplateId(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getSubjectLifeCycle(),"D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-主体生命周期不能为空",false);
      queryExecuteCycleLessStartBIgEndListComRespDto = fwAppExecuteCycleClient.queryExecuteCycleLessStartBIgEndListCom(queryExecuteCycleLessStartBIgEndListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsComRespDto = null;
    if(queryExecuteCycleBigStartLessEndListComRespDto !=null&&queryExecuteCycleLessStartBIgEndListComRespDto !=null){
          ImplementUnionMultipleDataSetsComReqDto implementUnionMultipleDataSetsComReqDto=new ImplementUnionMultipleDataSetsComReqDto();
  if(queryExecuteCycleBigStartLessEndListComRespDto!= null&&  queryExecuteCycleBigStartLessEndListComRespDto.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(queryExecuteCycleBigStartLessEndListComRespDto.getExecuteCycleStageList())){
      implementUnionMultipleDataSetsComReqDto.setDataSetsListOne(//objList-to-objLists
        queryExecuteCycleBigStartLessEndListComRespDto.getExecuteCycleStageList().stream().map(item -> {
      com.wicket.okrcomponent.integration.dto.DataSetsListOneDto elm = new com.wicket.okrcomponent.integration.dto.DataSetsListOneDto();
      if(item!=null){
      elm.setCustomField(item.getCycleId());//SimpleFieldAssign//sourceId:378990_2_70658
elm.setCustomField1(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:390868_2_70658
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887414_1_70658
    }
if(queryExecuteCycleLessStartBIgEndListComRespDto!= null&&  queryExecuteCycleLessStartBIgEndListComRespDto.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(queryExecuteCycleLessStartBIgEndListComRespDto.getExecuteCycleStageList())){
      implementUnionMultipleDataSetsComReqDto.setDataSetsListTwo(//objList-to-objLists
        queryExecuteCycleLessStartBIgEndListComRespDto.getExecuteCycleStageList().stream().map(item -> {
      com.wicket.okrcomponent.integration.dto.DataSetsListTwoDto elm = new com.wicket.okrcomponent.integration.dto.DataSetsListTwoDto();
      if(item!=null){
      elm.setCustomField(item.getCycleId());//SimpleFieldAssign//sourceId:378995_2_70658
elm.setCustomField1(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:390869_2_70658
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887415_1_70658
    }

    /*D2执行多数据集取并集(公共)[5320]   */

      implementUnionMultipleDataSetsComRespDto = fwCompInterfaceModeClient.implementUnionMultipleDataSetsCom(implementUnionMultipleDataSetsComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementManyFieldsDataSetDuplicateRemovalComRespDto implementManyFieldsDataSetDuplicateRemovalComRespDto = null;
    if(implementUnionMultipleDataSetsComRespDto !=null){
          ImplementManyFieldsDataSetDuplicateRemovalComReqDto implementManyFieldsDataSetDuplicateRemovalComReqDto=new ImplementManyFieldsDataSetDuplicateRemovalComReqDto();
  if(implementUnionMultipleDataSetsComRespDto!= null&&  implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList() !=null&& !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList())){
      implementManyFieldsDataSetDuplicateRemovalComReqDto.setDataSetDuplicateRemovalList(//objList-to-objLists
        implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList().stream().map(item -> {
      DataSetDuplicateRemovalDto elm = new DataSetDuplicateRemovalDto();
      if(item!=null){
      elm.setCommPrimaryKey(item.getCustomField1());//SimpleFieldAssign//sourceId:379001_2_70659
elm.setCustomField1(item.getCustomField());//SimpleFieldAssign//sourceId:390871_2_70659
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887417_1_70659
    }

    /*D2执行多字段数据集记录去重(公共)[7323]   */

      implementManyFieldsDataSetDuplicateRemovalComRespDto = fwCompInterfaceModeClient.implementManyFieldsDataSetDuplicateRemovalCom(implementManyFieldsDataSetDuplicateRemovalComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        ImplementCalcReceivingField003RespDto receptionServiceRes_4 = null;
    if(implementManyFieldsDataSetDuplicateRemovalComRespDto !=null){
          ImplementCalcReceivingField003ReqDto receptionServiceReq_2=new ImplementCalcReceivingField003ReqDto();
  if(implementManyFieldsDataSetDuplicateRemovalComRespDto!= null&&  implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList() !=null&& !CollectionUtil.isEmpty(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList())){
      receptionServiceReq_2.setUpdateCycleList(//objList-to-objLists
        implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList().stream().map(item -> {
          UpdateCycleDto elm = new UpdateCycleDto();
      if(item!=null){
      elm.setExecuteCycleStageId(item.getCommPrimaryKey());//SimpleFieldAssign//sourceId:390864_2_70660
elm.setUpdateCycleId(item.getCustomField1());//SimpleFieldAssign//sourceId:379010_2_70660
    }
          return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887433_1_70660
    }

    /*M4接收出参：更新周期ID列表[9537]  用于特殊方法接收上游入参。 */

      receptionServiceRes_4 = nbEvaCalc.implementCalcReceivingField003(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
           }
    }
AnalysisHistoryAndCurUpdateCycleComRespDto retData = new AnalysisHistoryAndCurUpdateCycleComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setUpdateCycleList(receptionServiceRes_3.getUpdateCycleList().stream().map(item -> BeanUtil.toBean(item, UpdateCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887437_1
    }




return retData;
  }
/**
   * D4执行修正进度值/实际值/费用金额(公共)[9862]
   * gen by moon at 6/24/2024, 4:42:10 AM
   */
  @Trace(operationName = "D4执行修正进度值/实际值/费用金额(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAdjustedProgressActualCostAmountComRespDto implementAdjustedProgressActualCostAmountCom(ImplementAdjustedProgressActualCostAmountComReqDto reqDto){


      ImplementCalcReceiveFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&& reqDto.getDataResultId() == null )) {
        //if(D4执行修正进度值/实际值/费用金额(公共).数据结果ID  值等于空 )  70754

//ModelCode: receptionService
        ImplementCalcReceiveFieldRespDto receptionServiceRes = null;
    ImplementCalcReceiveFieldReqDto receptionServiceReq=new ImplementCalcReceiveFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1891188_1_70756
receptionServiceReq.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1891189_1_70756
receptionServiceReq.setBudgetDisburse(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1891190_1_70756
    }

    /*M4接收进度值与实际值、预算支出金额出参[9725]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbEvaCalc.implementCalcReceiveField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
      }
else if((reqDto!= null&& reqDto.getDataResultId() != null )){
       //elseif(D4执行修正进度值/实际值/费用金额(公共).数据结果ID  值不等于空 )  70755

//ModelCode: receptionService
        ImplementCalcReceiveFieldRespDto receptionServiceRes_2 = null;
    ImplementCalcReceiveFieldReqDto receptionServiceReq_1=new ImplementCalcReceiveFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1891188_1_70757
receptionServiceReq_1.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1891189_1_70757
    }

    /*M4接收进度值与实际值、预算支出金额出参[9725]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbEvaCalc.implementCalcReceiveField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
    }
ImplementAdjustedProgressActualCostAmountComRespDto retData = new ImplementAdjustedProgressActualCostAmountComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setProgressValue(receptionServiceRes_1.getProgressValue());//SimpleFieldAssign//sourceId:1891194_1
retData.setActualValue(receptionServiceRes_1.getActualValue());//SimpleFieldAssign//sourceId:1891195_1
retData.setBudgetDisburse(receptionServiceRes_1.getBudgetDisburse());//SimpleFieldAssign//sourceId:1891196_1
    }




return retData;
  }
/**
   * D4分析数据点计算场景(公共)[9863]
   * gen by moon at 6/24/2024, 4:42:22 AM
   */
  @Trace(operationName = "D4分析数据点计算场景(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisDataTypeCalcSceneComRespDto analysisDataTypeCalcSceneCom(AnalysisDataTypeCalcSceneComReqDto reqDto){


      ImplementCalcReceiveFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M4约定审核计算场景  70758
      //ModelCode: receptionService
        ImplementCalcReceiveFieldRespDto receptionServiceRes = null;
    ImplementCalcReceiveFieldReqDto receptionServiceReq=new ImplementCalcReceiveFieldReqDto();
  receptionServiceReq.setCustomField1("PLAN_TARGET_CALC");//CUSTOM_CONVENTION//sourceId:1891289_1_70758
receptionServiceReq.setCustomField2("PLAN_FINACE_UPDATE");//CUSTOM_CONVENTION//sourceId:1891290_1_70758
receptionServiceReq.setCustomField3("PLAN_TARGET_AND_FINACE_CALC");//CUSTOM_CONVENTION//sourceId:1891291_1_70758

    /*M4约定审核计算场景[9725]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D4分析数据点计算场景(公共)-M4约定审核计算场景-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D4分析数据点计算场景(公共)-M4约定审核计算场景-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D4分析数据点计算场景(公共)-M4约定审核计算场景-自定义字段3不能为空",false);
      receptionServiceRes = nbEvaCalc.implementCalcReceiveField(receptionServiceReq);



if((reqDto!= null&& reqDto.getProgressValue() != null ||reqDto!= null&& reqDto.getActualValue() != null )&&(reqDto!= null&& reqDto.getBudgetDisburse() == null )) {
        //if((D4分析计算的数据点(公共).进度值（数值） 值不等于空  or D4分析计算的数据点(公共).实际值（数值） 值不等于空 ) and D4分析计算的数据点(公共).预算支出金额 值等于空 )  70759

//ModelCode: receptionService
        ImplementCalcReceiveFieldRespDto receptionServiceRes_2 = null;
    ImplementCalcReceiveFieldReqDto receptionServiceReq_1=new ImplementCalcReceiveFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setApproveCalcScene(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1891340_1_70760
    }

    /*M4接收审核的计算场景出参[9725]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getApproveCalcScene(),"D4分析数据点计算场景(公共)-M4接收审核的计算场景出参-审核的计算场景不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementCalcReceiveField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&& reqDto.getProgressValue() == null &&reqDto!= null&& reqDto.getActualValue() == null &&reqDto!= null&& reqDto.getBudgetDisburse() != null )){
       //elseif((D4分析计算的数据点(公共).进度值（数值） 值等于空  and D4分析计算的数据点(公共).实际值（数值） 值等于空  and D4分析计算的数据点(公共).预算支出金额 值不等于空 ))  70761

//ModelCode: receptionService
        ImplementCalcReceiveFieldRespDto receptionServiceRes_4 = null;
    ImplementCalcReceiveFieldReqDto receptionServiceReq_2=new ImplementCalcReceiveFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setApproveCalcScene(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1891340_1_70762
    }

    /*M4接收审核的计算场景出参[9725]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getApproveCalcScene(),"D4分析数据点计算场景(公共)-M4接收审核的计算场景出参-审核的计算场景不能为空",false);
      receptionServiceRes_4 = nbEvaCalc.implementCalcReceiveField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
else if((reqDto!= null&& reqDto.getProgressValue() != null ||reqDto!= null&& reqDto.getActualValue() != null )&&(reqDto!= null&& reqDto.getBudgetDisburse() != null )){
       //elseif((D4分析计算的数据点(公共).进度值（数值） 值不等于空  or D4分析计算的数据点(公共).实际值（数值） 值不等于空 ) and D4分析计算的数据点(公共).预算支出金额 值不等于空 )  70763

//ModelCode: receptionService
        ImplementCalcReceiveFieldRespDto receptionServiceRes_5 = null;
    ImplementCalcReceiveFieldReqDto receptionServiceReq_3=new ImplementCalcReceiveFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setApproveCalcScene(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1891340_1_70764
    }

    /*M4接收审核的计算场景出参[9725]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getApproveCalcScene(),"D4分析数据点计算场景(公共)-M4接收审核的计算场景出参-审核的计算场景不能为空",false);
      receptionServiceRes_5 = nbEvaCalc.implementCalcReceiveField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
    }
AnalysisDataTypeCalcSceneComRespDto retData = new AnalysisDataTypeCalcSceneComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setApproveCalcScene(receptionServiceRes_3.getApproveCalcScene());//SimpleFieldAssign//sourceId:1891342_1
    }




return retData;
  }
/**
   * D4执行检测汇报进度值(公共)[9885]
   * gen by moon at 6/28/2024, 2:14:10 AM
   */
  @Trace(operationName = "D4执行检测汇报进度值(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCheckReportProgressValueComRespDto implementCheckReportProgressValueCom(ImplementCheckReportProgressValueComReqDto reqDto){


      if((reqDto!= null&& reqDto.getLastEvaObjTargetCycleId() != null &&reqDto!= null&& reqDto.getPreviousCycleId() != null &&reqDto!= null&& reqDto.getProgressValue() != null &&reqDto!= null&&  reqDto.getIsLastCycle() !=null && reqDto.getIsLastCycle().equals("TRUE"))) {
        //if((D4执行检测汇报进度值(公共).上一被评对象目标周期ID 值不等于空  and D4执行检测汇报进度值(公共).上一归属周期ID 值不等于空  and D4执行检测汇报进度值(公共).进度值（数值） 值不等于空  and D4执行检测汇报进度值(公共).是否末级周期 等于 是))  71047

OmsStandardDataResult omsStandardDataResult = null;
    QueryStandardDataDetailReq queryStandardDataDetailReq=new QueryStandardDataDetailReq();
  queryStandardDataDetailReq.setDataType("PROGRESS_VALUE");//sourceId:1904595_1_71052
queryStandardDataDetailReq.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1904596_1_71052
if(reqDto!=null){
      queryStandardDataDetailReq.setEntityId(reqDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1904600_1_71052
queryStandardDataDetailReq.setPeriodId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1904598_1_71052
queryStandardDataDetailReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1904599_1_71052
queryStandardDataDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1904601_1_71052
    }

    /*4-01-01根据目标周期查上一个汇报周期的进度值标准数据[2696]   */
    Assert.isNull(queryStandardDataDetailReq.getDataType(),"D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-数据点类型不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getDataUsageSceneCode(),"D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getEntityId(),"D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getPeriodId(),"D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getParentSubMidCycleType(),"D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-父子中周期类型不能为空",false);
Assert.isNull(queryStandardDataDetailReq.getThemeContentId(),"D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-主题内容ID不能为空",false);
      omsStandardDataResult = mOmsStandardDataResultService.queryStandardDataDetail(queryStandardDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;



ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeComRespDto = null;
    if(omsStandardDataResult !=null){
          ImplementNumericalContrastMagnitudeComReqDto implementNumericalContrastMagnitudeComReqDto=new ImplementNumericalContrastMagnitudeComReqDto();
  if(reqDto!=null){
      implementNumericalContrastMagnitudeComReqDto.setCalcPara1(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1904602_1_71053
    }
if(omsStandardDataResult!=null){
      implementNumericalContrastMagnitudeComReqDto.setCalcPara2(omsStandardDataResult.getDataResult());//SimpleFieldAssign//sourceId:1904603_1_71053
    }

    /*D2执行两个数值对比大小(公共)[5551]   */
    Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara1(),"D4执行检测汇报进度值(公共)-D2执行两个数值对比大小(公共)-计算入参1不能为空",false);
Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara2(),"D4执行检测汇报进度值(公共)-D2执行两个数值对比大小(公共)-计算入参2不能为空",false);
      implementNumericalContrastMagnitudeComRespDto = fwCompInterfaceModeClient.implementNumericalContrastMagnitudeCom(implementNumericalContrastMagnitudeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementNumericalContrastMagnitudeComRespDto!= null&&  implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() !=null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("BEFORE"))) {
        //if(D2本次汇报进度值与上一个汇报周期进度值对比.数值比较结果 等于 之前（小于）)  71054

//异常结束 71056
      throw new BizException("3300220400474","对不起，您输入的进度值低于上一次汇报，请重新输入~",false);
      }
      }
ImplementCheckReportProgressValueComRespDto retData = new ImplementCheckReportProgressValueComRespDto();





return retData;
  }
/**
   * D4分析增财务父子中类型(公共)[9913]
   * gen by moon at 7/2/2024, 3:53:18 AM
   */
  @Trace(operationName = "D4分析增财务父子中类型(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisAddFinaceParentSubMidCycleTypeComRespDto analysisAddFinaceParentSubMidCycleTypeCom(AnalysisAddFinaceParentSubMidCycleTypeComReqDto reqDto){


      ImplementCalcReceivingField002RespDto receptionServiceRes_3 =null;
//virtualUsage M4约定父子中周期类型及父或子或中周期类型  71194
      //ModelCode: receptionService
        ImplementCalcReceivingField002RespDto receptionServiceRes = null;
    ImplementCalcReceivingField002ReqDto receptionServiceReq=new ImplementCalcReceivingField002ReqDto();
  receptionServiceReq.setCustomField1("PARENT_CYCLE");//CUSTOM_CONVENTION//sourceId:1914661_1_71194
receptionServiceReq.setCustomField2("SUB_CYCLE");//CUSTOM_CONVENTION//sourceId:1914662_1_71194
receptionServiceReq.setParentCycleType("PARENT_CYCLE");//sourceId:1914674_1_71194
receptionServiceReq.setMidCycleType("MID_CYCLE");//sourceId:1914675_1_71194
receptionServiceReq.setSubCycleType("SUB_CYCLE");//sourceId:1914676_1_71194

    /*M4约定父子中周期类型及父或子或中周期类型[9536]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D4分析增财务父子中类型(公共)-M4约定父子中周期类型及父或子或中周期类型-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D4分析增财务父子中类型(公共)-M4约定父子中周期类型及父或子或中周期类型-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getParentCycleType(),"D4分析增财务父子中类型(公共)-M4约定父子中周期类型及父或子或中周期类型-父周期类型不能为空",false);
Assert.isNull(receptionServiceReq.getMidCycleType(),"D4分析增财务父子中类型(公共)-M4约定父子中周期类型及父或子或中周期类型-中周期类型不能为空",false);
Assert.isNull(receptionServiceReq.getSubCycleType(),"D4分析增财务父子中类型(公共)-M4约定父子中周期类型及父或子或中周期类型-子周期类型不能为空",false);
      receptionServiceRes = nbEvaCalc.implementCalcReceivingField002(receptionServiceReq);



if((reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("SINGLE_CYCLE")||reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("IRREGULAR_CYCLE"))) {
        //if((D4分析增财务父子中类型(公共).周期模式 等于 单周期 or D4分析增财务父子中类型(公共).周期模式 等于 不规则周期))  71192

//ModelCode: receptionService
        ImplementCalcReceivingField002RespDto receptionServiceRes_2 = null;
    ImplementCalcReceivingField002ReqDto receptionServiceReq_1=new ImplementCalcReceivingField002ReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1914682_1_71195
receptionServiceReq_1.setParentCycleType(receptionServiceRes.getParentCycleType());//SimpleFieldAssign//sourceId:1914683_1_71195
    }

    /*M4接收父子中周期类型出参[9536]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getParentSubMidCycleType(),"D4分析增财务父子中类型(公共)-M4接收父子中周期类型出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementCalcReceivingField002(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("FATHER_SON_CYCLE"))){
       //elseif(D4分析增财务父子中类型(公共).周期模式 等于 父子周期)  71193

//ModelCode: receptionService
        ImplementCalcReceivingField002RespDto receptionServiceRes_4 = null;
    ImplementCalcReceivingField002ReqDto receptionServiceReq_2=new ImplementCalcReceivingField002ReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setParentSubMidCycleType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1914682_1_71196
receptionServiceReq_2.setSubCycleType(receptionServiceRes.getSubCycleType());//SimpleFieldAssign//sourceId:1914684_1_71196
    }

    /*M4接收父子中周期类型出参[9536]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getParentSubMidCycleType(),"D4分析增财务父子中类型(公共)-M4接收父子中周期类型出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_4 = nbEvaCalc.implementCalcReceivingField002(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
AnalysisAddFinaceParentSubMidCycleTypeComRespDto retData = new AnalysisAddFinaceParentSubMidCycleTypeComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setParentSubMidCycleType(receptionServiceRes_3.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1914691_1
retData.setParentCycleType(receptionServiceRes_3.getParentCycleType());//SimpleFieldAssign//sourceId:1914692_1
retData.setMidCycleType(receptionServiceRes_3.getMidCycleType());//SimpleFieldAssign//sourceId:1914693_1
retData.setSubCycleType(receptionServiceRes_3.getSubCycleType());//SimpleFieldAssign//sourceId:1914694_1
    }




return retData;
  }
/**
   * D4查询被评对象目标周期详情(跨)[9915]
   * gen by moon at 7/2/2024, 1:39:18 PM
   */
  @Trace(operationName = "D4查询被评对象目标周期详情(跨)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaObjTargetCycleOverDetailComRespDto queryEvaObjTargetCycleOverDetailCom(QueryEvaObjTargetCycleOverDetailComReqDto reqDto){


      QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto_1 =null;
//步骤0: D3-查询被评对象目标周期平台详情(公共) - queryEvaObjTargetCyclePlatformDetailCom
     QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1915684_1
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1915483_1
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1915485_1
queryEvaObjTargetCyclePlatformDetailComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1915488_1
queryEvaObjTargetCyclePlatformDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1915490_1
queryEvaObjTargetCyclePlatformDetailComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1915496_1
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1915497_1
queryEvaObjTargetCyclePlatformDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1915498_1
    }

    /*D3-查询被评对象目标周期平台详情(公共)[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D4查询被评对象目标周期详情(跨)-D3-查询被评对象目标周期平台详情(公共)-冗余评价模板ID不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = fwAppTargetCycleClient.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryEvaObjTargetCyclePlatformDetailComRespDto_1 = queryEvaObjTargetCyclePlatformDetailComRespDto;

QueryEvaObjTargetCycleOverDetailComRespDto retData = new QueryEvaObjTargetCycleOverDetailComRespDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto_1!=null){
      retData.setEvaObjTargetCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1915558_1
retData.setEvaObjTargetCycleCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1915559_1
retData.setParentEvaObjTargetCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1915560_1
retData.setTargetCycleName(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetCycleName());//SimpleFieldAssign//sourceId:1915561_1
retData.setCyclelAlias(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCyclelAlias());//SimpleFieldAssign//sourceId:1915562_1
retData.setEvaluationObjectId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaluationObjectId());//SimpleFieldAssign//sourceId:1915563_1
retData.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1915564_1
retData.setEvaObjTableTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:1915565_1
retData.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1915566_1
retData.setTreeTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTreeTypeCode());//SimpleFieldAssign//sourceId:1915567_1
retData.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1915568_1
retData.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1915569_1
retData.setIsUseFirstDept(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIsUseFirstDept());//SimpleFieldAssign//sourceId:1915570_1
retData.setIndicatorKind(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIndicatorKind());//SimpleFieldAssign//sourceId:1915571_1
retData.setIsCustomObjective(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIsCustomObjective());//SimpleFieldAssign//sourceId:1915572_1
retData.setCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleId());//SimpleFieldAssign//sourceId:1915573_1
retData.setCycleStandardName(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleStandardName());//SimpleFieldAssign//sourceId:1915574_1
retData.setIsParentCycle(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIsParentCycle());//SimpleFieldAssign//sourceId:1915575_1
retData.setIsMetaphase(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIsMetaphase());//SimpleFieldAssign//sourceId:1915576_1
retData.setIsSubCycle(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIsSubCycle());//SimpleFieldAssign//sourceId:1915577_1
retData.setCycleStartTime(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1915578_1
retData.setCycleEndTime(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1915579_1
retData.setCycleTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1915580_1
retData.setCycleTypeInstanceCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1915581_1
retData.setCycleNumberShortName(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleNumberShortName());//SimpleFieldAssign//sourceId:1915582_1
retData.setHaveProcessCycle(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getHaveProcessCycle());//SimpleFieldAssign//sourceId:1915583_1
retData.setTargetReached(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetReached());//SimpleFieldAssign//sourceId:1915584_1
retData.setTaskStatus(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTaskStatus());//SimpleFieldAssign//sourceId:1915585_1
retData.setBizSceneCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getBizSceneCode());//SimpleFieldAssign//sourceId:1915586_1
retData.setEvaluationSubjectTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:1915587_1
retData.setPlanningType(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getPlanningType());//SimpleFieldAssign//sourceId:1915588_1
retData.setEvaluationTemplateTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:1915589_1
retData.setTargetId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetId());//SimpleFieldAssign//sourceId:1915590_1
retData.setEvaluationTemplateId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1915591_1
retData.setEvaluationSubjectId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1915592_1
retData.setTargetTreeOrderNumber(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetTreeOrderNumber());//SimpleFieldAssign//sourceId:1915593_1
retData.setOrderNumber(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getOrderNumber());//SimpleFieldAssign//sourceId:1915594_1
retData.setDutyBodyOrderNum(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getDutyBodyOrderNum());//SimpleFieldAssign//sourceId:1915595_1
retData.setRelativeOrderNumber(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1915596_1
retData.setPersonalOrderNumber(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getPersonalOrderNumber());//SimpleFieldAssign//sourceId:1915597_1
retData.setWeightOrderNumber(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getWeightOrderNumber());//SimpleFieldAssign//sourceId:1915598_1
retData.setSortCreateTime(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getSortCreateTime());//SimpleFieldAssign//sourceId:1915599_1
retData.setBatchCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getBatchCode());//SimpleFieldAssign//sourceId:1915600_1
retData.setOperationInductionId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getOperationInductionId());//SimpleFieldAssign//sourceId:1915601_1
retData.setCreateInductionId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCreateInductionId());//SimpleFieldAssign//sourceId:1915602_1
retData.setReleaseInductionId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getReleaseInductionId());//SimpleFieldAssign//sourceId:1915603_1
retData.setSpaceId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getSpaceId());//SimpleFieldAssign//sourceId:1915604_1
retData.setAppId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getAppId());//SimpleFieldAssign//sourceId:1915605_1
    }




return retData;
  }
/**
   * D4计算因子达成度转得分(公共)[9947]
   * gen by moon at 7/16/2024, 4:52:50 PM
   */
  @Trace(operationName = "D4计算因子达成度转得分(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public CalculateFactorReachToScoreComRespDto calculateFactorReachToScoreCom(CalculateFactorReachToScoreComReqDto reqDto){


      ImplementCalcReceivingField006RespDto receptionServiceRes_1 =null;
if((reqDto!= null&& reqDto.getReach() != null )) {
        //if(D4计算因子达成度转得分(公共).达成度 值不等于空 )  71608

    CalculateDivisionOfTwoNumComRespDto calculateDivisionOfTwoNumComRespDto = null;
    CalculateDivisionOfTwoNumComReqDto calculateDivisionOfTwoNumComReqDto=new CalculateDivisionOfTwoNumComReqDto();
  calculateDivisionOfTwoNumComReqDto.setCalcPara2(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:1925405_1_71609
calculateDivisionOfTwoNumComReqDto.setDecimalPointRules(Long.valueOf(10));//CUSTOM_CONVENTION//sourceId:1925407_1_71609
calculateDivisionOfTwoNumComReqDto.setDecimalDigitsLastRules("MALING");//sourceId:1925408_1_71609
    if(reqDto!=null){
      calculateDivisionOfTwoNumComReqDto.setCalcPara1(reqDto.getReach());//SimpleFieldAssign//sourceId:1925404_1_71609
    }

    /*D4达成度/100[4841]   */
    Assert.isNull(calculateDivisionOfTwoNumComReqDto.getCalcPara1(),"D4计算因子达成度转得分(公共)-D4达成度/100-计算入参1不能为空",false);
    Assert.isNull(calculateDivisionOfTwoNumComReqDto.getCalcPara2(),"D4计算因子达成度转得分(公共)-D4达成度/100-计算入参2不能为空",false);
    Assert.isNull(calculateDivisionOfTwoNumComReqDto.getDecimalPointRules(),"D4计算因子达成度转得分(公共)-D4达成度/100-小数点规则不能为空",false);
    Assert.isNull(calculateDivisionOfTwoNumComReqDto.getDecimalDigitsLastRules(),"D4计算因子达成度转得分(公共)-D4达成度/100-小数最后一位规则不能为空",false);
    calculateDivisionOfTwoNumComRespDto = calculationRulesService.calculateDivisionOfTwoNumCom(calculateDivisionOfTwoNumComReqDto)/*vcase invoke isSameApp*/;



    CalculateMultiplyTwoValuesComRespDto calculateMultiplyTwoValuesComRespDto = null;
    if(calculateDivisionOfTwoNumComRespDto !=null){
        CalculateMultiplyTwoValuesComReqDto calculateMultiplyTwoValuesComReqDto=new CalculateMultiplyTwoValuesComReqDto();
  calculateMultiplyTwoValuesComReqDto.setDecimalPointRules(Long.valueOf(10));//CUSTOM_CONVENTION//sourceId:1925412_1_71610
calculateMultiplyTwoValuesComReqDto.setDecimalDigitsLastRules("MALING");//sourceId:1925413_1_71610
        if(calculateDivisionOfTwoNumComRespDto!=null){
      calculateMultiplyTwoValuesComReqDto.setComFloatField1(calculateDivisionOfTwoNumComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1925409_1_71610
        }
        if(reqDto!=null){
      calculateMultiplyTwoValuesComReqDto.setComFloatField2(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1925410_1_71610
        }

        /*D4目标得分=达成度/10*权重分[5443]   */
        Assert.isNull(calculateMultiplyTwoValuesComReqDto.getComFloatField1(),"D4计算因子达成度转得分(公共)-D4目标得分=达成度/10*权重分-通用数值字段1（小数型）不能为空",false);
        Assert.isNull(calculateMultiplyTwoValuesComReqDto.getComFloatField2(),"D4计算因子达成度转得分(公共)-D4目标得分=达成度/10*权重分-通用数值字段2（小数型）不能为空",false);
        Assert.isNull(calculateMultiplyTwoValuesComReqDto.getDecimalPointRules(),"D4计算因子达成度转得分(公共)-D4目标得分=达成度/10*权重分-小数点规则不能为空",false);
        Assert.isNull(calculateMultiplyTwoValuesComReqDto.getDecimalDigitsLastRules(),"D4计算因子达成度转得分(公共)-D4目标得分=达成度/10*权重分-小数最后一位规则不能为空",false);
        calculateMultiplyTwoValuesComRespDto = interfaceModeService.calculateMultiplyTwoValuesCom(calculateMultiplyTwoValuesComReqDto)/*vcase invoke isSameApp*/;



    }
    //ModelCode: receptionService
        ImplementCalcReceivingField006RespDto receptionServiceRes = null;
    if(calculateMultiplyTwoValuesComRespDto !=null){
          ImplementCalcReceivingField006ReqDto receptionServiceReq=new ImplementCalcReceivingField006ReqDto();
        if(calculateMultiplyTwoValuesComRespDto!=null){
      receptionServiceReq.setTargetScore(calculateMultiplyTwoValuesComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1925476_1_71611
        }

        /*M4接收目标得分[9540]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTargetScore(),"D4计算因子达成度转得分(公共)-M4接收目标得分-目标得分不能为空",false);
      receptionServiceRes = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
    }



}

      CalculateFactorReachToScoreComRespDto retData = new CalculateFactorReachToScoreComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setTargetScore(receptionServiceRes_1.getTargetScore());//SimpleFieldAssign//sourceId:1925484_1
      }




      return retData;
  }
/**
   * D4执行修正填报标准数据是否最新(公共)[9958]
   * gen by moon at 7/14/2024, 7:12:30 PM
   */
  @Trace(operationName = "D4执行修正填报标准数据是否最新(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAdjustedFillInStandardDataIsNewestComRespDto implementAdjustedFillInStandardDataIsNewestCom(ImplementAdjustedFillInStandardDataIsNewestComReqDto reqDto){


      if((reqDto!= null&& reqDto.getProgressValue() != null ||reqDto!= null&& reqDto.getActualValue() != null )||(reqDto!= null&& reqDto.getDataResultId() != null &&reqDto!= null&& reqDto.getBudgetDisburse() != null )) {
        //if((D4执行修正填报标准数据是否最新(公共).进度值（数值） 值不等于空  or D4执行修正填报标准数据是否最新(公共).实际值（数值） 值不等于空 ) or (D4执行修正填报标准数据是否最新(公共).数据结果ID  值不等于空  and D4执行修正填报标准数据是否最新(公共).预算支出金额 值不等于空 ))  71573

ObtainTargetBelongCycleComRespDto obtainTargetBelongCycleComRespDto = null;
    ObtainTargetBelongCycleComReqDto obtainTargetBelongCycleComReqDto=new ObtainTargetBelongCycleComReqDto();
  if(reqDto!=null){
      obtainTargetBelongCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1931929_1_71574
obtainTargetBelongCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1931930_1_71574
obtainTargetBelongCycleComReqDto.setPreviousCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1931931_1_71574
obtainTargetBelongCycleComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1932020_1_71574
obtainTargetBelongCycleComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1931932_1_71574
obtainTargetBelongCycleComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1931933_1_71574
obtainTargetBelongCycleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1931934_1_71574
    }

    /*D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)[8739]   */
    Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaObjEntityId(),"D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaObjTypeCode(),"D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-主树被评对象类型编码不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getPreviousCycleId(),"D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-上一归属周期ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getParentSubMidCycleType(),"D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-父子中过程周期类型不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getEntityId(),"D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-归属内容表主键ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaluationTemplateId(),"D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-冗余评价模板ID不能为空",false);
Assert.isNull(obtainTargetBelongCycleComReqDto.getSpaceId(),"D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-创建于空间ID不能为空",false);
      obtainTargetBelongCycleComRespDto = fwAppTargetCalcClient.obtainTargetBelongCycleCom(obtainTargetBelongCycleComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((obtainTargetBelongCycleComRespDto!= null&& obtainTargetBelongCycleComRespDto.getFromContentEntityId() != null )) {
        //if(D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期).来自内容表主键ID 值不等于空 )  71575

QueryCycleStageDataDetailComRespDto queryCycleStageDataDetailComRespDto = null;
    if(obtainTargetBelongCycleComRespDto !=null){
          QueryCycleStageDataDetailComReqDto queryCycleStageDataDetailComReqDto=new QueryCycleStageDataDetailComReqDto();
  if(obtainTargetBelongCycleComRespDto!=null){
      queryCycleStageDataDetailComReqDto.setCycleStageDataId(obtainTargetBelongCycleComRespDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1932071_1_71578
    }
if(reqDto!=null){
      queryCycleStageDataDetailComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1932072_1_71578
queryCycleStageDataDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1932073_1_71578
    }

    /*D3查询当前周期阶段资料详情(用于判断当前周期阶段资料是否已提交)[3962]   */
    Assert.isNull(queryCycleStageDataDetailComReqDto.getCycleStageDataId(),"D4执行修正填报标准数据是否最新(公共)-D3查询当前周期阶段资料详情(用于判断当前周期阶段资料是否已提交)-周期阶段资料记录ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getThemeContentId(),"D4执行修正填报标准数据是否最新(公共)-D3查询当前周期阶段资料详情(用于判断当前周期阶段资料是否已提交)-主题内容ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailComReqDto.getSpaceId(),"D4执行修正填报标准数据是否最新(公共)-D3查询当前周期阶段资料详情(用于判断当前周期阶段资料是否已提交)-创建于空间ID不能为空",false);
      queryCycleStageDataDetailComRespDto = fwAppCycleStageDataClient.queryCycleStageDataDetailCom(queryCycleStageDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((queryCycleStageDataDetailComRespDto!= null&&  queryCycleStageDataDetailComRespDto.getSubjectLifeCycle() !=null && queryCycleStageDataDetailComRespDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))&&(reqDto!= null&& reqDto.getProgressValue() != null ||reqDto!= null&& reqDto.getActualValue() != null )) {
        //if(D3查询当前周期阶段资料详情(用于判断当前周期阶段资料是否已提交).主体生命周期 等于 当前有效 and (D4执行修正填报标准数据是否最新(公共).进度值（数值） 值不等于空  or D4执行修正填报标准数据是否最新(公共).实际值（数值） 值不等于空 ))  71579

List<OmsStandardDataResult> listOmsStandardDataResult =new ArrayList<>();
    QueryStandardDataBaseListReq queryStandardDataBaseListReq=new QueryStandardDataBaseListReq();
  queryStandardDataBaseListReq.setResultType("MANUAL_INPUT");//sourceId:1931982_1_71580
if(reqDto!=null){
      queryStandardDataBaseListReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1932023_1_71580
queryStandardDataBaseListReq.setPeriodId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1931984_1_71580
queryStandardDataBaseListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1931985_1_71580
queryStandardDataBaseListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1931986_1_71580
queryStandardDataBaseListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1931987_1_71580
    }

    /*4-01-01查询当前周期人工录入标准数据列表[4495]   */
    Assert.isNull(queryStandardDataBaseListReq.getResultType(),"D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-结果产生类型不能为空",false);
Assert.isNull(queryStandardDataBaseListReq.getParentSubMidCycleType(),"D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-父子中周期类型不能为空",false);
Assert.isNull(queryStandardDataBaseListReq.getPeriodId(),"D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-周期ID不能为空",false);
Assert.isNull(queryStandardDataBaseListReq.getEntityId(),"D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataBaseListReq.getThemeContentId(),"D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataBaseListReq.getSpaceId(),"D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-创建于空间ID不能为空",false);
      listOmsStandardDataResult = mOmsStandardDataResultService.queryStandardDataBaseList(queryStandardDataBaseListReq)/*vcase invoke 本地 method 方法调用;*/;



boolean bOOLEAN ;
    if(listOmsStandardDataResult !=null&& !CollectionUtil.isEmpty(listOmsStandardDataResult)&& listOmsStandardDataResult.size()>0 ){
          List<OmsStandardDataResult> listOmsStandardDataResult_2=new ArrayList<>();
  if(listOmsStandardDataResult!= null&& !CollectionUtil.isEmpty(listOmsStandardDataResult)&&  listOmsStandardDataResult !=null&& !CollectionUtil.isEmpty(listOmsStandardDataResult)){
      listOmsStandardDataResult_2 = //objList-to-objLists
        listOmsStandardDataResult.stream().map(item -> {
      OmsStandardDataResult elm = new OmsStandardDataResult();
      elm.setDataResultId(item.getDataResultId());//SimpleFieldAssign//sourceId:393060_2_71581
elm.setIsNewData("FALSE");//sourceId:393061_2_71581
elm.setIsUpdateCycleNewData("FALSE");//sourceId:393064_2_71581
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1931981_1_71581
    }

    /*4-01-01批量回写当前周期人工录入标准数据（归属与更新是否最新为否）[5688]   */

      bOOLEAN = mOmsStandardDataResultService.batchUpdateStandardData(listOmsStandardDataResult_2)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
if((reqDto!= null&& reqDto.getDataResultId() != null &&reqDto!= null&& reqDto.getBudgetDisburse() != null )) {
        //if((D4执行修正填报标准数据是否最新(公共).数据结果ID  值不等于空  and D4执行修正填报标准数据是否最新(公共).预算支出金额 值不等于空 ))  71583

boolean bOOLEAN_1 ;
    OmsStandardDataResult omsStandardDataResult=new OmsStandardDataResult();
  omsStandardDataResult.setIsUpdateCycleNewData("FALSE");//sourceId:1932111_1_71584
omsStandardDataResult.setIsNewData("FALSE");//sourceId:1932112_1_71584
if(reqDto!=null){
      omsStandardDataResult.setDataResultId(reqDto.getDataResultId());//SimpleFieldAssign//sourceId:1932110_1_71584
    }

    /*4-01-01回写预算支出金额标准数据（归属与更新周期是否最新为否）[2860]   */
    Assert.isNull(omsStandardDataResult.getDataResultId(),"D4执行修正填报标准数据是否最新(公共)-4-01-01回写预算支出金额标准数据（归属与更新周期是否最新为否）-数据结果ID 不能为空",false);
Assert.isNull(omsStandardDataResult.getIsUpdateCycleNewData(),"D4执行修正填报标准数据是否最新(公共)-4-01-01回写预算支出金额标准数据（归属与更新周期是否最新为否）-是否更新周期最新数据不能为空",false);
Assert.isNull(omsStandardDataResult.getIsNewData(),"D4执行修正填报标准数据是否最新(公共)-4-01-01回写预算支出金额标准数据（归属与更新周期是否最新为否）-是否归属周期最新数据不能为空",false);
      bOOLEAN_1 = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult)/*vcase invoke 本地 method 方法调用;*/;



      }
      }
      }
ImplementAdjustedFillInStandardDataIsNewestComRespDto retData = new ImplementAdjustedFillInStandardDataIsNewestComRespDto();





return retData;
  }
/**
   * D4执行修正并计算目标标准数据(公共)[9959]
   * gen by moon at 9/28/2024, 10:21:13 PM
   */
  @Trace(operationName = "D4执行修正并计算目标标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAdjustedAndCalcTargetStandardDataComRespDto implementAdjustedAndCalcTargetStandardDataCom(ImplementAdjustedAndCalcTargetStandardDataComReqDto reqDto){


      //步骤0: M4执行计算公共接收字段（特殊方法） - implementCalcReceiveField
     //ModelCode: receptionService
        ImplementCalcReceiveFieldRespDto receptionServiceRes = null;
    ImplementCalcReceiveFieldReqDto receptionServiceReq=new ImplementCalcReceiveFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setApproveCalcScene(reqDto.getApproveCalcScene());//SimpleFieldAssign//sourceId:1932015_1
receptionServiceReq.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1931682_1
receptionServiceReq.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1931681_1
receptionServiceReq.setDataResultId(reqDto.getDataResultId());//SimpleFieldAssign//sourceId:1931680_1
receptionServiceReq.setBudgetDisburse(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1931683_1
receptionServiceReq.setAccountSubjectld(reqDto.getAccountSubjectld());//SimpleFieldAssign//sourceId:1932006_1
receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1931997_1
receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1931998_1
receptionServiceReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1932027_1
receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1931686_1
receptionServiceReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1932016_1
receptionServiceReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1932008_1
receptionServiceReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1931688_1
receptionServiceReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1932011_1
receptionServiceReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1931690_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1931999_1
    }

    /*M4接收入参字段[9725]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getApproveCalcScene(),"D4执行修正并计算目标标准数据(公共)-M4接收入参字段-审核的计算场景不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjEntityId(),"D4执行修正并计算目标标准数据(公共)-M4接收入参字段-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTypeCode(),"D4执行修正并计算目标标准数据(公共)-M4接收入参字段-主树被评对象类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getParentSubMidCycleType(),"D4执行修正并计算目标标准数据(公共)-M4接收入参字段-父子中周期类型不能为空",false);
Assert.isNull(receptionServiceReq.getCycleId(),"D4执行修正并计算目标标准数据(公共)-M4接收入参字段-归属周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getCycleStartTime(),"D4执行修正并计算目标标准数据(公共)-M4接收入参字段-周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq.getCycleTypeCode(),"D4执行修正并计算目标标准数据(公共)-M4接收入参字段-周期类型标识不能为空",false);
Assert.isNull(receptionServiceReq.getEntityId(),"D4执行修正并计算目标标准数据(公共)-M4接收入参字段-归属内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getBelongToContentId(),"D4执行修正并计算目标标准数据(公共)-M4接收入参字段-数据归属内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getThemeContentId(),"D4执行修正并计算目标标准数据(公共)-M4接收入参字段-主题内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D4执行修正并计算目标标准数据(公共)-M4接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbEvaCalc.implementCalcReceiveField(receptionServiceReq);




//步骤1: D4提交汇报进度值实际值等(公共) - commitToBeReportedTaskStdDataCom
     CommitToBeReportedTaskStdDataComRespDto commitToBeReportedTaskStdDataComRespDto = null;
     CommitToBeReportedTaskStdDataComReqDto commitToBeReportedTaskStdDataComReqDto=new CommitToBeReportedTaskStdDataComReqDto();
  commitToBeReportedTaskStdDataComReqDto.setResultType("MANUAL_INPUT");//sourceId:1931569_1
commitToBeReportedTaskStdDataComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1931576_1
if(reqDto!=null){
      commitToBeReportedTaskStdDataComReqDto.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1931563_1
commitToBeReportedTaskStdDataComReqDto.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1931564_1
commitToBeReportedTaskStdDataComReqDto.setBudgetDisburse(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1931565_1
commitToBeReportedTaskStdDataComReqDto.setAccountSubjectld(reqDto.getAccountSubjectld());//SimpleFieldAssign//sourceId:1931575_1
commitToBeReportedTaskStdDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1931574_1
commitToBeReportedTaskStdDataComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1931566_1
commitToBeReportedTaskStdDataComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1931570_1
commitToBeReportedTaskStdDataComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1931571_1
commitToBeReportedTaskStdDataComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1931572_1
commitToBeReportedTaskStdDataComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1931573_1
commitToBeReportedTaskStdDataComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1931567_1
commitToBeReportedTaskStdDataComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1931568_1
    }

    /*D4提交汇报进度值实际值等(公共)[8637]   */
    Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getResultType(),"D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-结果产生类型不能为空",false);
Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getCycleId(),"D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-归属周期ID不能为空",false);
Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getCycleTypeCode(),"D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-周期类型标识不能为空",false);
Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getEntityId(),"D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getBelongToContentId(),"D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getEvaObjEntityId(),"D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getEvaObjTypeCode(),"D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-主树被评对象类型编码不能为空",false);
Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getEvaluationTemplateId(),"D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getSubjectLifeCycle(),"D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-主体生命周期不能为空",false);
Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getSpaceId(),"D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-创建于空间ID不能为空",false);
      commitToBeReportedTaskStdDataComRespDto = targetCalcService.commitToBeReportedTaskStdDataCom(commitToBeReportedTaskStdDataComReqDto)/*vcase invoke isSameApp*/;




ImplementAdjustedAndCalcTargetStandardDataComRespDto retData = new ImplementAdjustedAndCalcTargetStandardDataComRespDto();





return retData;
  }
/**
   * D4执行删标准数据(公共)[9983]
   * gen by moon at 7/20/2024, 3:12:25 PM
   */
  @Trace(operationName = "D4执行删标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDelStandardDataComRespDto implementDelStandardDataCom(ImplementDelStandardDataComReqDto reqDto){


      //步骤0: 4-01-01查标准数据列表（归属周期开始大于等于&归属周期结束小于等于） - queryStandardDataList
     List<OmsStandardDataResult> listOmsStandardDataResult =new ArrayList<>();
    QueryStandardDataListReq queryStandardDataListReq=new QueryStandardDataListReq();
  if(reqDto!=null){
      queryStandardDataListReq.setFromContentEntityId(reqDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1940088_1
queryStandardDataListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1940086_1
    }

    /*4-01-01查标准数据列表[7719]   */
    Assert.isNull(queryStandardDataListReq.getFromContentEntityId(),"D4执行删标准数据(公共)-4-01-01查标准数据列表-来自内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataListReq.getThemeContentId(),"D4执行删标准数据(公共)-4-01-01查标准数据列表-主题内容ID不能为空",false);
      listOmsStandardDataResult = mOmsStandardDataResultService.queryStandardDataList(queryStandardDataListReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤1: 4-01-01批量删标准数据 - batchDeleteStandardData
     boolean bOOLEAN ;
    if(listOmsStandardDataResult !=null&& !CollectionUtil.isEmpty(listOmsStandardDataResult)&& listOmsStandardDataResult.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsStandardDataResult!= null&& !CollectionUtil.isEmpty(listOmsStandardDataResult)&&  listOmsStandardDataResult !=null&& !CollectionUtil.isEmpty(listOmsStandardDataResult)){
      listString = listOmsStandardDataResult.stream().map(item->item.getDataResultId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:1940064_1
    }

    /*4-01-01批量删标准数据[4216]   */

      bOOLEAN = mOmsStandardDataResultService.batchDeleteStandardData(listString)/*vcase invoke 本地 method 方法调用;*/;



           }

ImplementDelStandardDataComRespDto retData = new ImplementDelStandardDataComRespDto();





return retData;
  }
/**
   * D4非末级周期向左克隆标准数据(公共)[10106]
   * gen by moon at 10/9/2024, 9:35:59 PM
   */
  @Trace(operationName = "D4非末级周期向左克隆标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementNonFinalCycleLeftCloneStandardDataComRespDto implementNonFinalCycleLeftCloneStandardDataCom(ImplementNonFinalCycleLeftCloneStandardDataComReqDto reqDto){


      ImplementCloneProgressActualValueEtcComRespDto implementCloneProgressActualValueEtcComRespDto_1 =null;
//virtualUsage M4约定数据点：进度值与实际值  72324
      //ModelCode: receptionService
        ImplementCalcReceivingField006RespDto receptionServiceRes = null;
    ImplementCalcReceivingField006ReqDto receptionServiceReq=new ImplementCalcReceivingField006ReqDto();
  receptionServiceReq.setCustomField1("PROGRESS_VALUE");//CUSTOM_CONVENTION//sourceId:1978442_1_72324
receptionServiceReq.setCustomField2("ACTUAL_VALUE");//CUSTOM_CONVENTION//sourceId:1978443_1_72324
receptionServiceReq.setCustomField3("OBJECTIVE_SCORE");//CUSTOM_CONVENTION//sourceId:1978452_1_72324

    /*M4约定数据点：进度值与实际值[9540]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D4非末级周期向左克隆标准数据(公共)-M4约定数据点：进度值与实际值-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D4非末级周期向左克隆标准数据(公共)-M4约定数据点：进度值与实际值-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D4非末级周期向左克隆标准数据(公共)-M4约定数据点：进度值与实际值-自定义字段3不能为空",false);
      receptionServiceRes = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq);



//virtualUsage D2查主客观答案得分单位配置答案  72328
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1978477_1_72328
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SUBJECTIVE_FULL_MARK_UNIT");//CUSTOM_CONVENTION//sourceId:1978478_1_72328
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1978479_1_72328
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1978476_1_72328
    }

    /*D2查主客观答案得分单位配置答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D4非末级周期向左克隆标准数据(公共)-D2查主客观答案得分单位配置答案-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D4非末级周期向左克隆标准数据(公共)-D2查主客观答案得分单位配置答案-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D4非末级周期向左克隆标准数据(公共)-D2查主客观答案得分单位配置答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D4非末级周期向左克隆标准数据(公共)-D2查主客观答案得分单位配置答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D3分析非末级周期的最近可循环周期ID(公共)  73167
      AnalysisNonFinalNextCycleIdComRespDto analysisNonFinalNextCycleIdComRespDto = null;
    AnalysisNonFinalNextCycleIdComReqDto analysisNonFinalNextCycleIdComReqDto=new AnalysisNonFinalNextCycleIdComReqDto();
  if(reqDto!=null){
      analysisNonFinalNextCycleIdComReqDto.setRecentlyNewCycleId(reqDto.getRecentlyNewCycleId());//SimpleFieldAssign//sourceId:2017332_1_73167
analysisNonFinalNextCycleIdComReqDto.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2017333_1_73167
analysisNonFinalNextCycleIdComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:2017334_1_73167
    }

    /*D3分析非末级周期的最近可循环周期ID(公共)[10258]   */
    Assert.isNull(analysisNonFinalNextCycleIdComReqDto.getEvaObjTargetCycleId(),"D4非末级周期向左克隆标准数据(公共)-D3分析非末级周期的最近可循环周期ID(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(analysisNonFinalNextCycleIdComReqDto.getEvaluationTemplateId(),"D4非末级周期向左克隆标准数据(公共)-D3分析非末级周期的最近可循环周期ID(公共)-冗余评价模板ID不能为空",false);
      analysisNonFinalNextCycleIdComRespDto = fwAppEvaCalcClient.analysisNonFinalNextCycleIdCom(analysisNonFinalNextCycleIdComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D4查询最近可循环最新进度值实际值(用于克隆)  72316
      ImplementCloneProgressActualValueEtcComRespDto implementCloneProgressActualValueEtcComRespDto = null;
    if(analysisNonFinalNextCycleIdComRespDto !=null){
    ImplementCloneProgressActualValueEtcComReqDto implementCloneProgressActualValueEtcComReqDto=new ImplementCloneProgressActualValueEtcComReqDto();
  implementCloneProgressActualValueEtcComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1977958_1_72316
implementCloneProgressActualValueEtcComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1977959_1_72316
if(reqDto!=null){
      implementCloneProgressActualValueEtcComReqDto.setEvaProgressCalcCode(reqDto.getEvaProgressCalcCode());//SimpleFieldAssign//sourceId:1977947_1_72316
implementCloneProgressActualValueEtcComReqDto.setEvaActualCalcCode(reqDto.getEvaActualCalcCode());//SimpleFieldAssign//sourceId:1977948_1_72316
implementCloneProgressActualValueEtcComReqDto.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1977949_1_72316
implementCloneProgressActualValueEtcComReqDto.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1977950_1_72316
implementCloneProgressActualValueEtcComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1977951_1_72316
implementCloneProgressActualValueEtcComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1977952_1_72316
implementCloneProgressActualValueEtcComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1977960_1_72316
implementCloneProgressActualValueEtcComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1977953_1_72316
implementCloneProgressActualValueEtcComReqDto.setCycleId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1977954_1_72316
implementCloneProgressActualValueEtcComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1977955_1_72316
implementCloneProgressActualValueEtcComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1977956_1_72316
implementCloneProgressActualValueEtcComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1977957_1_72316
    }
if(analysisNonFinalNextCycleIdComRespDto!=null){
      implementCloneProgressActualValueEtcComReqDto.setRecentlyNewCycleId(analysisNonFinalNextCycleIdComRespDto.getRecentlyNewCycleId());//SimpleFieldAssign//sourceId:1977967_1_72316
    }

    /*D4查询最近可循环最新进度值实际值(用于克隆)[9429]   */
    Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getEvaObjEntityId(),"D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getEvaObjTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-主树被评对象类型编码不能为空",false);
Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getParentSubMidCycleType(),"D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-父子中周期类型不能为空",false);
Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getEntityId(),"D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-归属内容表主键ID不能为空",false);
Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getCycleId(),"D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-归属周期ID不能为空",false);
Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getCycleTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-周期类型标识不能为空",false);
Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getBelongToContentId(),"D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-数据归属内容表主键ID不能为空",false);
Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getEvaluationTemplateId(),"D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-冗余评价模板ID不能为空",false);
Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getSubjectLifeCycle(),"D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-主体生命周期不能为空",false);
Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getSpaceId(),"D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-创建于空间ID不能为空",false);
      implementCloneProgressActualValueEtcComRespDto = targetCalcService.implementCloneProgressActualValueEtcCom(implementCloneProgressActualValueEtcComReqDto)/*vcase invoke isSameApp*/;


      implementCloneProgressActualValueEtcComRespDto_1 = implementCloneProgressActualValueEtcComRespDto;
           }
if((implementCloneProgressActualValueEtcComRespDto!= null&& implementCloneProgressActualValueEtcComRespDto.getProgressValue() != null ||implementCloneProgressActualValueEtcComRespDto!= null&& implementCloneProgressActualValueEtcComRespDto.getActualValue() != null )) {
        //if((D4查询最近可循环最新进度值实际值(用于克隆).进度值（数值） 值不等于空  or D4查询最近可循环最新进度值实际值(用于克隆).实际值（数值） 值不等于空 ))  72317

CalculateFinalObjectiveScoreComRespDto calculateFinalObjectiveScoreComRespDto = null;
    if(implementCloneProgressActualValueEtcComRespDto !=null){
          CalculateFinalObjectiveScoreComReqDto calculateFinalObjectiveScoreComReqDto=new CalculateFinalObjectiveScoreComReqDto();
  calculateFinalObjectiveScoreComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1977973_1_72318
if(reqDto!=null){
      calculateFinalObjectiveScoreComReqDto.setTargetAttributionCycleId(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:1977983_1_72318
calculateFinalObjectiveScoreComReqDto.setActualValueCalcFormula(reqDto.getEvaActualCalcCode());//SimpleFieldAssign//sourceId:1977968_1_72318
calculateFinalObjectiveScoreComReqDto.setCalcOrClone(reqDto.getEvaReportScoreCalcCode());//SimpleFieldAssign//sourceId:1977969_1_72318
calculateFinalObjectiveScoreComReqDto.setReportScoreCountFormula(reqDto.getRankOrDownCalc());//SimpleFieldAssign//sourceId:1977974_1_72318
calculateFinalObjectiveScoreComReqDto.setSubAndObjModel(reqDto.getSubAndObjModel());//SimpleFieldAssign//sourceId:1977970_1_72318
calculateFinalObjectiveScoreComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1977984_1_72318
calculateFinalObjectiveScoreComReqDto.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1977985_1_72318
calculateFinalObjectiveScoreComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1977976_1_72318
calculateFinalObjectiveScoreComReqDto.setTargetCycleContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1977975_1_72318
calculateFinalObjectiveScoreComReqDto.setTargetValueType(reqDto.getTargetValueType());//SimpleFieldAssign//sourceId:1977971_1_72318
calculateFinalObjectiveScoreComReqDto.setEvaTargetStartValue(reqDto.getEvaTargetStartValue());//SimpleFieldAssign//sourceId:1977978_1_72318
calculateFinalObjectiveScoreComReqDto.setEvaTargetValue(reqDto.getEvaTargetValue());//SimpleFieldAssign//sourceId:1977979_1_72318
calculateFinalObjectiveScoreComReqDto.setEvaTargetDiagnosticValue(reqDto.getEvaTargetDiagnosticValue());//SimpleFieldAssign//sourceId:1977980_1_72318
calculateFinalObjectiveScoreComReqDto.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1977977_1_72318
calculateFinalObjectiveScoreComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1977972_1_72318
    }
if(implementCloneProgressActualValueEtcComRespDto!=null){
      calculateFinalObjectiveScoreComReqDto.setActualValue(implementCloneProgressActualValueEtcComRespDto.getActualValue());//SimpleFieldAssign//sourceId:1977981_1_72318
    }

    /*D3计算指标最终客观得分(公共)[9442]   */
    Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetAttributionCycleId(),"D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-目标归属周期ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getUpdateCycleId(),"D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-更新周期ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getEvaObjTargetCycleId(),"D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetCycleContentTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetCycleContentId(),"D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getWeightScore(),"D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-权重分值不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getEvaluationTemplateId(),"D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getSpaceId(),"D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-创建于空间ID不能为空",false);
      calculateFinalObjectiveScoreComRespDto = fwAppTargetCalcClient.calculateFinalObjectiveScoreCom(calculateFinalObjectiveScoreComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementCloneProgressActualValueEtcComRespDto!= null&& implementCloneProgressActualValueEtcComRespDto.getProgressValue() != null )) {
        //if(D4查询最近可循环最新进度值实际值(用于克隆).进度值（数值） 值不等于空 )  72319

RefreshDataPointStandardDataComRespDto refreshDataPointStandardDataComRespDto = null;
    if(implementCloneProgressActualValueEtcComRespDto !=null){
          RefreshDataPointStandardDataComReqDto refreshDataPointStandardDataComReqDto=new RefreshDataPointStandardDataComReqDto();
  refreshDataPointStandardDataComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1978202_1_72322
refreshDataPointStandardDataComReqDto.setIsSystemDocking("FALSE");//sourceId:1978203_1_72322
refreshDataPointStandardDataComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1978205_1_72322
refreshDataPointStandardDataComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1978226_1_72322
refreshDataPointStandardDataComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1978239_1_72322
if(implementCloneProgressActualValueEtcComRespDto!=null){
      refreshDataPointStandardDataComReqDto.setDataResult(implementCloneProgressActualValueEtcComRespDto.getProgressValue());//SimpleFieldAssign//sourceId:1978200_1_72322
refreshDataPointStandardDataComReqDto.setUnit(implementCloneProgressActualValueEtcComRespDto.getProgressValueUnit());//SimpleFieldAssign//sourceId:1978201_1_72322
    }
if(receptionServiceRes!=null){
      refreshDataPointStandardDataComReqDto.setDataType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1978204_1_72322
    }
if(reqDto!=null){
      refreshDataPointStandardDataComReqDto.setPreviousCycleId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1978242_1_72322
refreshDataPointStandardDataComReqDto.setLastEntityId(reqDto.getLastEntityId());//SimpleFieldAssign//sourceId:1978245_1_72322
refreshDataPointStandardDataComReqDto.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1978243_1_72322
refreshDataPointStandardDataComReqDto.setPeriodId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1978206_1_72322
refreshDataPointStandardDataComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1978207_1_72322
refreshDataPointStandardDataComReqDto.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1978208_1_72322
refreshDataPointStandardDataComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1978209_1_72322
refreshDataPointStandardDataComReqDto.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1978210_1_72322
refreshDataPointStandardDataComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1978211_1_72322
refreshDataPointStandardDataComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1978212_1_72322
refreshDataPointStandardDataComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1978213_1_72322
refreshDataPointStandardDataComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1978214_1_72322
refreshDataPointStandardDataComReqDto.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1978215_1_72322
refreshDataPointStandardDataComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1978216_1_72322
refreshDataPointStandardDataComReqDto.setIsWorkCycleData(reqDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1978217_1_72322
refreshDataPointStandardDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1978241_1_72322
refreshDataPointStandardDataComReqDto.setWorkCycleUpdateSlice(reqDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1978218_1_72322
refreshDataPointStandardDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1978219_1_72322
refreshDataPointStandardDataComReqDto.setFromContentTableTypeCode(reqDto.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1978220_1_72322
refreshDataPointStandardDataComReqDto.setFromContentEntityId(reqDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1978221_1_72322
refreshDataPointStandardDataComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1978222_1_72322
refreshDataPointStandardDataComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1978223_1_72322
refreshDataPointStandardDataComReqDto.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1978224_1_72322
refreshDataPointStandardDataComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1978225_1_72322
refreshDataPointStandardDataComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1978227_1_72322
refreshDataPointStandardDataComReqDto.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1978229_1_72322
refreshDataPointStandardDataComReqDto.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1978230_1_72322
refreshDataPointStandardDataComReqDto.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1978231_1_72322
refreshDataPointStandardDataComReqDto.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1978246_1_72322
refreshDataPointStandardDataComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1978232_1_72322
refreshDataPointStandardDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1978233_1_72322
refreshDataPointStandardDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1978234_1_72322
refreshDataPointStandardDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1978235_1_72322
refreshDataPointStandardDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1978236_1_72322
refreshDataPointStandardDataComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1978237_1_72322
refreshDataPointStandardDataComReqDto.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1978244_1_72322
refreshDataPointStandardDataComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1978238_1_72322
refreshDataPointStandardDataComReqDto.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1978240_1_72322
    }

    /*D4克隆数据点标准数据(公共)[8559]   */
    Assert.isNull(refreshDataPointStandardDataComReqDto.getDataResult(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据值结果不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getUnit(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-冗余单位不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getResultType(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-结果产生类型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getIsSystemDocking(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否系统对接不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getDataType(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据点类型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getDataUsageSceneCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据业务场景不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getPeriodId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getCycleStartTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期开始时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getCycleEndTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期结束时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getCycleTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期类型标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getUpdateCycleId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getUpdateCycleStartTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期开始时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getUpdateCycleEndTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期结束时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getUpdateCycleTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getStandardDataCalcCycleModel(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算周期五模型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getParentSubMidCycleType(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-父子中周期类型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getIsWorkCycleData(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否工作周期数据不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getEventBatchUpdateCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getWorkCycleUpdateSlice(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-工作周期更新切片不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getCalcStartTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算开始时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getTableTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getEntityId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getBelongToContentTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getBelongToContentId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getThemeContentTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getThemeContentId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getPersonLiableTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getPersonLiableObjId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getBizRoleObjId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getBizRoleObjCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getBizRoleObjName(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getBelongToPersonalIdentityId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getBelongToPersonalIdentityRoleCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象角色编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getBelongToPersonalIdentityTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getSubjectLifeCycle(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主体生命周期不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto.getOperationInductionId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-操作人就职记录ID不能为空",false);
      refreshDataPointStandardDataComRespDto = standardDataService.refreshDataPointStandardDataCom(refreshDataPointStandardDataComReqDto)/*vcase invoke isSameApp*/;



           }
      }
if((implementCloneProgressActualValueEtcComRespDto!= null&& implementCloneProgressActualValueEtcComRespDto.getActualValue() != null )) {
        //if(D4查询最近可循环最新进度值实际值(用于克隆).实际值（数值） 值不等于空 )  72321

RefreshDataPointStandardDataComRespDto refreshDataPointStandardDataComRespDto_1 = null;
    if(implementCloneProgressActualValueEtcComRespDto !=null){
          RefreshDataPointStandardDataComReqDto refreshDataPointStandardDataComReqDto_1=new RefreshDataPointStandardDataComReqDto();
  refreshDataPointStandardDataComReqDto_1.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1978202_1_72323
refreshDataPointStandardDataComReqDto_1.setIsSystemDocking("FALSE");//sourceId:1978203_1_72323
refreshDataPointStandardDataComReqDto_1.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1978205_1_72323
refreshDataPointStandardDataComReqDto_1.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1978226_1_72323
refreshDataPointStandardDataComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1978239_1_72323
if(implementCloneProgressActualValueEtcComRespDto!=null){
      refreshDataPointStandardDataComReqDto_1.setDataResult(implementCloneProgressActualValueEtcComRespDto.getActualValue());//SimpleFieldAssign//sourceId:1978200_1_72323
refreshDataPointStandardDataComReqDto_1.setUnit(implementCloneProgressActualValueEtcComRespDto.getActualValueUnit());//SimpleFieldAssign//sourceId:1978201_1_72323
    }
if(receptionServiceRes!=null){
      refreshDataPointStandardDataComReqDto_1.setDataType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1978204_1_72323
    }
if(reqDto!=null){
      refreshDataPointStandardDataComReqDto_1.setPreviousCycleId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1978242_1_72323
refreshDataPointStandardDataComReqDto_1.setLastEntityId(reqDto.getLastEntityId());//SimpleFieldAssign//sourceId:1978245_1_72323
refreshDataPointStandardDataComReqDto_1.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1978243_1_72323
refreshDataPointStandardDataComReqDto_1.setPeriodId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1978206_1_72323
refreshDataPointStandardDataComReqDto_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1978207_1_72323
refreshDataPointStandardDataComReqDto_1.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1978208_1_72323
refreshDataPointStandardDataComReqDto_1.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1978209_1_72323
refreshDataPointStandardDataComReqDto_1.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1978210_1_72323
refreshDataPointStandardDataComReqDto_1.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1978211_1_72323
refreshDataPointStandardDataComReqDto_1.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1978212_1_72323
refreshDataPointStandardDataComReqDto_1.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1978213_1_72323
refreshDataPointStandardDataComReqDto_1.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1978214_1_72323
refreshDataPointStandardDataComReqDto_1.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1978215_1_72323
refreshDataPointStandardDataComReqDto_1.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1978216_1_72323
refreshDataPointStandardDataComReqDto_1.setIsWorkCycleData(reqDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1978217_1_72323
refreshDataPointStandardDataComReqDto_1.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1978241_1_72323
refreshDataPointStandardDataComReqDto_1.setWorkCycleUpdateSlice(reqDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1978218_1_72323
refreshDataPointStandardDataComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1978219_1_72323
refreshDataPointStandardDataComReqDto_1.setFromContentTableTypeCode(reqDto.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1978220_1_72323
refreshDataPointStandardDataComReqDto_1.setFromContentEntityId(reqDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1978221_1_72323
refreshDataPointStandardDataComReqDto_1.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1978222_1_72323
refreshDataPointStandardDataComReqDto_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1978223_1_72323
refreshDataPointStandardDataComReqDto_1.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1978224_1_72323
refreshDataPointStandardDataComReqDto_1.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1978225_1_72323
refreshDataPointStandardDataComReqDto_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1978227_1_72323
refreshDataPointStandardDataComReqDto_1.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1978229_1_72323
refreshDataPointStandardDataComReqDto_1.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1978230_1_72323
refreshDataPointStandardDataComReqDto_1.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1978231_1_72323
refreshDataPointStandardDataComReqDto_1.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1978246_1_72323
refreshDataPointStandardDataComReqDto_1.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1978232_1_72323
refreshDataPointStandardDataComReqDto_1.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1978233_1_72323
refreshDataPointStandardDataComReqDto_1.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1978234_1_72323
refreshDataPointStandardDataComReqDto_1.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1978235_1_72323
refreshDataPointStandardDataComReqDto_1.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1978236_1_72323
refreshDataPointStandardDataComReqDto_1.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1978237_1_72323
refreshDataPointStandardDataComReqDto_1.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1978244_1_72323
refreshDataPointStandardDataComReqDto_1.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1978238_1_72323
refreshDataPointStandardDataComReqDto_1.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1978240_1_72323
    }

    /*D4克隆数据点标准数据(公共)[8559]   */
    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getDataResult(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据值结果不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getUnit(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-冗余单位不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getResultType(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-结果产生类型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getIsSystemDocking(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否系统对接不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getDataType(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据点类型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getDataUsageSceneCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据业务场景不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getPeriodId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getCycleStartTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期开始时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getCycleEndTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期结束时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getCycleTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期类型标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getUpdateCycleId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getUpdateCycleStartTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期开始时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getUpdateCycleEndTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期结束时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getUpdateCycleTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getStandardDataCalcCycleModel(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算周期五模型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getParentSubMidCycleType(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-父子中周期类型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getIsWorkCycleData(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否工作周期数据不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getEventBatchUpdateCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getWorkCycleUpdateSlice(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-工作周期更新切片不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getCalcStartTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算开始时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getTableTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getEntityId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBelongToContentTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBelongToContentId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getThemeContentTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getThemeContentId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getPersonLiableTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getPersonLiableObjId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBizRoleObjId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBizRoleObjCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBizRoleObjName(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBelongToPersonalIdentityId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBelongToPersonalIdentityRoleCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象角色编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBelongToPersonalIdentityTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getSubjectLifeCycle(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主体生命周期不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_1.getOperationInductionId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-操作人就职记录ID不能为空",false);
      refreshDataPointStandardDataComRespDto_1 = standardDataService.refreshDataPointStandardDataCom(refreshDataPointStandardDataComReqDto_1)/*vcase invoke isSameApp*/;



           }
      }
if((calculateFinalObjectiveScoreComRespDto!= null&& calculateFinalObjectiveScoreComRespDto.getObjectiveScore() != null )) {
        //if(D3计算指标最终客观得分(公共).客观得分 值不等于空 )  72326

RefreshDataPointStandardDataComRespDto refreshDataPointStandardDataComRespDto_2 = null;
    if(calculateFinalObjectiveScoreComRespDto !=null&&queryConfItemMatchAnswerDetailComRespDto !=null){
          RefreshDataPointStandardDataComReqDto refreshDataPointStandardDataComReqDto_2=new RefreshDataPointStandardDataComReqDto();
  refreshDataPointStandardDataComReqDto_2.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1978202_1_72327
refreshDataPointStandardDataComReqDto_2.setIsSystemDocking("FALSE");//sourceId:1978203_1_72327
refreshDataPointStandardDataComReqDto_2.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1978205_1_72327
refreshDataPointStandardDataComReqDto_2.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1978226_1_72327
refreshDataPointStandardDataComReqDto_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1978239_1_72327
if(calculateFinalObjectiveScoreComRespDto!=null){
      refreshDataPointStandardDataComReqDto_2.setDataResult(calculateFinalObjectiveScoreComRespDto.getObjectiveScore());//SimpleFieldAssign//sourceId:1978200_1_72327
    }
if(queryConfItemMatchAnswerDetailComRespDto!=null){
      refreshDataPointStandardDataComReqDto_2.setUnit(queryConfItemMatchAnswerDetailComRespDto.getConfOptionName());//SimpleFieldAssign//sourceId:1978201_1_72327
    }
if(receptionServiceRes!=null){
      refreshDataPointStandardDataComReqDto_2.setDataType(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1978204_1_72327
    }
if(reqDto!=null){
      refreshDataPointStandardDataComReqDto_2.setPreviousCycleId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1978242_1_72327
refreshDataPointStandardDataComReqDto_2.setLastEntityId(reqDto.getLastEntityId());//SimpleFieldAssign//sourceId:1978245_1_72327
refreshDataPointStandardDataComReqDto_2.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1978243_1_72327
refreshDataPointStandardDataComReqDto_2.setPeriodId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1978206_1_72327
refreshDataPointStandardDataComReqDto_2.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1978207_1_72327
refreshDataPointStandardDataComReqDto_2.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1978208_1_72327
refreshDataPointStandardDataComReqDto_2.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1978209_1_72327
refreshDataPointStandardDataComReqDto_2.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1978210_1_72327
refreshDataPointStandardDataComReqDto_2.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1978211_1_72327
refreshDataPointStandardDataComReqDto_2.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1978212_1_72327
refreshDataPointStandardDataComReqDto_2.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1978213_1_72327
refreshDataPointStandardDataComReqDto_2.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1978214_1_72327
refreshDataPointStandardDataComReqDto_2.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1978215_1_72327
refreshDataPointStandardDataComReqDto_2.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1978216_1_72327
refreshDataPointStandardDataComReqDto_2.setIsWorkCycleData(reqDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1978217_1_72327
refreshDataPointStandardDataComReqDto_2.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1978241_1_72327
refreshDataPointStandardDataComReqDto_2.setWorkCycleUpdateSlice(reqDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1978218_1_72327
refreshDataPointStandardDataComReqDto_2.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1978219_1_72327
refreshDataPointStandardDataComReqDto_2.setFromContentTableTypeCode(reqDto.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1978220_1_72327
refreshDataPointStandardDataComReqDto_2.setFromContentEntityId(reqDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1978221_1_72327
refreshDataPointStandardDataComReqDto_2.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1978222_1_72327
refreshDataPointStandardDataComReqDto_2.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1978223_1_72327
refreshDataPointStandardDataComReqDto_2.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1978224_1_72327
refreshDataPointStandardDataComReqDto_2.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1978225_1_72327
refreshDataPointStandardDataComReqDto_2.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1978227_1_72327
refreshDataPointStandardDataComReqDto_2.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1978229_1_72327
refreshDataPointStandardDataComReqDto_2.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1978230_1_72327
refreshDataPointStandardDataComReqDto_2.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1978231_1_72327
refreshDataPointStandardDataComReqDto_2.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1978246_1_72327
refreshDataPointStandardDataComReqDto_2.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1978232_1_72327
refreshDataPointStandardDataComReqDto_2.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1978233_1_72327
refreshDataPointStandardDataComReqDto_2.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1978234_1_72327
refreshDataPointStandardDataComReqDto_2.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1978235_1_72327
refreshDataPointStandardDataComReqDto_2.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1978236_1_72327
refreshDataPointStandardDataComReqDto_2.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1978237_1_72327
refreshDataPointStandardDataComReqDto_2.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1978244_1_72327
refreshDataPointStandardDataComReqDto_2.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1978238_1_72327
refreshDataPointStandardDataComReqDto_2.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1978240_1_72327
    }

    /*D4克隆数据点标准数据(公共)[8559]   */
    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getDataResult(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据值结果不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getUnit(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-冗余单位不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getResultType(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-结果产生类型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getIsSystemDocking(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否系统对接不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getDataType(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据点类型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getDataUsageSceneCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据业务场景不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getPeriodId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getCycleStartTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期开始时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getCycleEndTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期结束时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getCycleTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期类型标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getUpdateCycleId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getUpdateCycleStartTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期开始时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getUpdateCycleEndTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期结束时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getUpdateCycleTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getStandardDataCalcCycleModel(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算周期五模型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getParentSubMidCycleType(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-父子中周期类型不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getIsWorkCycleData(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否工作周期数据不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getEventBatchUpdateCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getWorkCycleUpdateSlice(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-工作周期更新切片不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getCalcStartTime(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算开始时间不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getTableTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getEntityId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBelongToContentTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBelongToContentId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getThemeContentTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getThemeContentId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getPersonLiableTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getPersonLiableObjId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBizRoleObjId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBizRoleObjCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBizRoleObjName(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBelongToPersonalIdentityId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象ID不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBelongToPersonalIdentityRoleCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象角色编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBelongToPersonalIdentityTypeCode(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象类型编码不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getSubjectLifeCycle(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主体生命周期不能为空",false);
Assert.isNull(refreshDataPointStandardDataComReqDto_2.getOperationInductionId(),"D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-操作人就职记录ID不能为空",false);
      refreshDataPointStandardDataComRespDto_2 = standardDataService.refreshDataPointStandardDataCom(refreshDataPointStandardDataComReqDto_2)/*vcase invoke isSameApp*/;



           }
      }
      }
ImplementNonFinalCycleLeftCloneStandardDataComRespDto retData = new ImplementNonFinalCycleLeftCloneStandardDataComRespDto();
  if(implementCloneProgressActualValueEtcComRespDto_1!=null){
      retData.setProgressValue(implementCloneProgressActualValueEtcComRespDto_1.getProgressValue());//SimpleFieldAssign//sourceId:1978480_1
retData.setParentProgressValue(implementCloneProgressActualValueEtcComRespDto_1.getParentProgressValue());//SimpleFieldAssign//sourceId:1978481_1
retData.setProgressValueUnit(implementCloneProgressActualValueEtcComRespDto_1.getProgressValueUnit());//SimpleFieldAssign//sourceId:1978543_1
retData.setActualValue(implementCloneProgressActualValueEtcComRespDto_1.getActualValue());//SimpleFieldAssign//sourceId:1978482_1
retData.setParentActualValue(implementCloneProgressActualValueEtcComRespDto_1.getParentActualValue());//SimpleFieldAssign//sourceId:1978483_1
retData.setActualValueUnit(implementCloneProgressActualValueEtcComRespDto_1.getActualValueUnit());//SimpleFieldAssign//sourceId:1978544_1
    }




return retData;
  }
/**
   * D4判断当前周期是否存在标准数据(公共)[10259]
   * gen by moon at 10/15/2024, 8:51:38 PM
   */
  @Trace(operationName = "D4判断当前周期是否存在标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeCurCycleIsHaveDataComRespDto judgeCurCycleIsHaveDataCom(JudgeCurCycleIsHaveDataComReqDto reqDto){


      ImplementCalcReceivingField006RespDto receptionServiceRes_3 =null;
//virtualUsage M4约定结果产生类型、是否  73175
      //ModelCode: receptionService
        ImplementCalcReceivingField006RespDto receptionServiceRes = null;
    ImplementCalcReceivingField006ReqDto receptionServiceReq=new ImplementCalcReceivingField006ReqDto();
  receptionServiceReq.setCustomField1("MANUAL_INPUT");//CUSTOM_CONVENTION//sourceId:2017750_1_73175
receptionServiceReq.setCustomField2("TRUE");//CUSTOM_CONVENTION//sourceId:2017852_1_73175

    /*M4约定结果产生类型、是否[9540]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D4判断当前周期是否存在标准数据(公共)-M4约定结果产生类型、是否-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D4判断当前周期是否存在标准数据(公共)-M4约定结果产生类型、是否-自定义字段2不能为空",false);
      receptionServiceRes = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq);



if((reqDto!= null&&  reqDto.getBrushStandardDataSence() !=null && reqDto.getBrushStandardDataSence().equals("REPORT_DATA_SENCE"))) {
        //if(D4判断当前周期是否存在标准数据(公共).刷新标准数据场景 等于 汇报数据场景)  73171

QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto = null;
    QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto=new QueryStandardDataOfObjectDetailComReqDto();
  queryStandardDataOfObjectDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2017539_1_73173
queryStandardDataOfObjectDetailComReqDto.setIsArchive("FALSE");//sourceId:2017547_1_73173
if(receptionServiceRes!=null){
      queryStandardDataOfObjectDetailComReqDto.setResultType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:2017550_1_73173
    }
if(reqDto!=null){
      queryStandardDataOfObjectDetailComReqDto.setPeriodId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:2017523_1_73173
queryStandardDataOfObjectDetailComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2017537_1_73173
queryStandardDataOfObjectDetailComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2017525_1_73173
queryStandardDataOfObjectDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2017527_1_73173
queryStandardDataOfObjectDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2017534_1_73173
    }

    /*D4查询归属主体标准数据详情(公共)[8850]   */
    Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getPeriodId(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getParentSubMidCycleType(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-父子中周期类型不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getThemeContentId(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getDataUsageSceneCode(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getIsArchive(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-是否存档不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getSpaceId(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-创建于空间ID不能为空",false);
      queryStandardDataOfObjectDetailComRespDto = standardDataService.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto)/*vcase invoke isSameApp*/;



if((queryStandardDataOfObjectDetailComRespDto!= null&& queryStandardDataOfObjectDetailComRespDto.getDataResultId() != null &&reqDto!= null&& reqDto.getFromContentEntityId() != null )) {
        //if((D4查询当前周期是否存在人工填报标准数据(用于判断当前牌是否执行目标计算).数据结果ID  值不等于空  and D4判断当前周期是否存在标准数据(公共).来自内容表主键ID 值不等于空 ))  73177

//ModelCode: receptionService
        ImplementCalcReceivingField006RespDto receptionServiceRes_2 = null;
    ImplementCalcReceivingField006ReqDto receptionServiceReq_1=new ImplementCalcReceivingField006ReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setDataIsCheckPass(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:2017850_1_73179
    }

    /*M4接收出参字段：数据是否校验通过[9540]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getDataIsCheckPass(),"D4判断当前周期是否存在标准数据(公共)-M4接收出参字段：数据是否校验通过-数据是否校验通过不能为空",false);
      receptionServiceRes_2 = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
      }
else if((reqDto!= null&&  reqDto.getBrushStandardDataSence() !=null && reqDto.getBrushStandardDataSence().equals("REVISE_TARGET_DATA_SENCE"))){
       //elseif(D4判断当前周期是否存在标准数据(公共).刷新标准数据场景 等于 修订目标数据场景)  73172

QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto_2 = null;
    QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto_1=new QueryStandardDataOfObjectDetailComReqDto();
  queryStandardDataOfObjectDetailComReqDto_1.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2017539_1_73174
queryStandardDataOfObjectDetailComReqDto_1.setIsArchive("FALSE");//sourceId:2017547_1_73174
if(reqDto!=null){
      queryStandardDataOfObjectDetailComReqDto_1.setPeriodId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:2017523_1_73174
queryStandardDataOfObjectDetailComReqDto_1.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2017525_1_73174
queryStandardDataOfObjectDetailComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2017527_1_73174
queryStandardDataOfObjectDetailComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2017534_1_73174
    }

    /*D4查询归属主体标准数据详情(公共)[8850]   */
    Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getPeriodId(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getParentSubMidCycleType(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-父子中周期类型不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getThemeContentId(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getDataUsageSceneCode(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getIsArchive(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-是否存档不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getSpaceId(),"D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-创建于空间ID不能为空",false);
      queryStandardDataOfObjectDetailComRespDto_2 = standardDataService.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto_1)/*vcase invoke isSameApp*/;



if((queryStandardDataOfObjectDetailComRespDto_2!= null&& queryStandardDataOfObjectDetailComRespDto_2.getDataResultId() != null )) {
        //if(D4查询当前周期是否存在标准数据(用于判断当前牌是否执行目标计算).数据结果ID  值不等于空 )  73181

//ModelCode: receptionService
        ImplementCalcReceivingField006RespDto receptionServiceRes_4 = null;
    ImplementCalcReceivingField006ReqDto receptionServiceReq_2=new ImplementCalcReceivingField006ReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setDataIsCheckPass(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:2017850_1_73182
    }

    /*M4接收出参字段：数据是否校验通过[9540]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getDataIsCheckPass(),"D4判断当前周期是否存在标准数据(公共)-M4接收出参字段：数据是否校验通过-数据是否校验通过不能为空",false);
      receptionServiceRes_4 = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
      }
    }
JudgeCurCycleIsHaveDataComRespDto retData = new JudgeCurCycleIsHaveDataComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setDataIsCheckPass(receptionServiceRes_3.getDataIsCheckPass());//SimpleFieldAssign//sourceId:2017856_1
    }




return retData;
  }
/**
   * D4查询标准数据by小于等于开始时间大于等于结束时间详情(公共)[10278]
   * gen by moon at 10/22/2024, 12:07:12 AM
   */
  @Trace(operationName = "D4查询标准数据by小于等于开始时间大于等于结束时间详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryStandardDataBySmallStartAndBigEndDetailComRespDto queryStandardDataBySmallStartAndBigEndDetailCom(QueryStandardDataBySmallStartAndBigEndDetailComReqDto reqDto){


      OmsStandardDataResult omsStandardDataResult_1 =null;
//步骤0: 4-01-01查询标准数据详情by小于等于开始时间大于等于结束时间 - queryStandardDataBySmallStartAndBigEndDetail
     OmsStandardDataResult omsStandardDataResult = null;
    QueryStandardDataBySmallStartAndBigEndDetailReq queryStandardDataBySmallStartAndBigEndDetailReq=new QueryStandardDataBySmallStartAndBigEndDetailReq();
  if(reqDto!=null){
      queryStandardDataBySmallStartAndBigEndDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2021841_1
queryStandardDataBySmallStartAndBigEndDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:2021842_1
queryStandardDataBySmallStartAndBigEndDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:2021843_1
queryStandardDataBySmallStartAndBigEndDetailReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2021844_1
queryStandardDataBySmallStartAndBigEndDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:2021845_1
queryStandardDataBySmallStartAndBigEndDetailReq.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:2021846_1
queryStandardDataBySmallStartAndBigEndDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2021847_1
    }

    /*4-01-01查询标准数据详情by小于等于开始时间大于等于结束时间[10277]   */

      omsStandardDataResult = mOmsStandardDataResultService.queryStandardDataBySmallStartAndBigEndDetail(queryStandardDataBySmallStartAndBigEndDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsStandardDataResult_1 = omsStandardDataResult;

QueryStandardDataBySmallStartAndBigEndDetailComRespDto retData = new QueryStandardDataBySmallStartAndBigEndDetailComRespDto();
  if(omsStandardDataResult_1!=null){
      retData.setDataResultId(omsStandardDataResult_1.getDataResultId());//SimpleFieldAssign//sourceId:2021858_1
retData.setDataResult(omsStandardDataResult_1.getDataResult());//SimpleFieldAssign//sourceId:2021859_1
    }




return retData;
  }
/**
   * D4执行当前内容或兄弟计算修订异常场景(公共)[10288]
   * gen by moon at 3/8/2025, 12:06:29 AM
   */
  @Trace(operationName = "D4执行当前内容或兄弟计算修订异常场景(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCurConBrotherCalcReviseAnormalSceneComRespDto implementCurConBrotherCalcReviseAnormalSceneCom(ImplementCurConBrotherCalcReviseAnormalSceneComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getDataCalcNormalAbnormal() !=null && reqDto.getDataCalcNormalAbnormal().equals("ABNORMAL_SCENE"))) {
        //if(D4执行当前内容或兄弟计算修订异常场景(公共).数据计算正常与异常场景 等于 异常场景)  73368

QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = null;
    QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto=new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
  queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2024862_1_73370
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2024863_1_73370
if(reqDto!=null){
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2025259_1_73370
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2024864_1_73370
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2024869_1_73370
    }

    /*D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)[9935]   */
    Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getCycleStartTime(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-周期开始时间不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaluationTemplateId(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjEntityId(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTypeCode(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象类型编码不能为空",false);
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementLoopCalcCyclesStandardDataComRespDto implementLoopCalcCyclesStandardDataComRespDto = null;
    if(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto !=null){
          ImplementLoopCalcCyclesStandardDataComReqDto implementLoopCalcCyclesStandardDataComReqDto=new ImplementLoopCalcCyclesStandardDataComReqDto();
  if(reqDto!=null){
      implementLoopCalcCyclesStandardDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2025246_1_73374
implementLoopCalcCyclesStandardDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2025247_1_73374
implementLoopCalcCyclesStandardDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2025248_1_73374
    }
if(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto!= null&&  queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList() !=null&& !CollectionUtil.isEmpty(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList())){
      implementLoopCalcCyclesStandardDataComReqDto.setTargetBelongCycleList(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList().stream().map(item -> BeanUtil.toBean(item, com.wicket.okrcalc.biz.service.dto.common.TargetBelongCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2025245_1_73374
    }

    /*D4执行循环计算不同周期标准数据异常或修订场景(公共)[10290]   */
    Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto.getEventBatchUpdateCode(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto.getCalcStartTime(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-计算开始时间不能为空",false);
Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto.getTargetScoreUnit(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-目标得分单位不能为空",false);
      implementLoopCalcCyclesStandardDataComRespDto = implementLoopCalcCyclesStandardDataCom(implementLoopCalcCyclesStandardDataComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      }
else if((reqDto!= null&&  reqDto.getDataCalcNormalAbnormal() !=null && reqDto.getDataCalcNormalAbnormal().equals("REVISE_ABNORMAL_SCENE")&&reqDto!= null&& reqDto.getParentEvaObjTargetCycleId() != null )){
       //elseif((D4执行当前内容或兄弟计算修订异常场景(公共).数据计算正常与异常场景 等于 修订异常场景 and D4执行当前内容或兄弟计算修订异常场景(公共).上级被评对象目标周期标识 值不等于空 ))  73369

QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 = null;
    QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1=new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
  queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2024862_1_73371
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2024863_1_73371
if(reqDto!=null){
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2024871_1_73371
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2024864_1_73371
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2024869_1_73371
    }

    /*D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)[9935]   */
    Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getCycleStartTime(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-周期开始时间不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaluationTemplateId(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaObjEntityId(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaObjTypeCode(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象类型编码不能为空",false);
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementLoopCalcCyclesStandardDataComRespDto implementLoopCalcCyclesStandardDataComRespDto_1 = null;
    if(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 !=null){
          ImplementLoopCalcCyclesStandardDataComReqDto implementLoopCalcCyclesStandardDataComReqDto_1=new ImplementLoopCalcCyclesStandardDataComReqDto();
  if(reqDto!=null){
      implementLoopCalcCyclesStandardDataComReqDto_1.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2025246_1_73375
implementLoopCalcCyclesStandardDataComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2025247_1_73375
implementLoopCalcCyclesStandardDataComReqDto_1.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2025248_1_73375
    }
if(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2!= null&&  queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList() !=null&& !CollectionUtil.isEmpty(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList())){
      implementLoopCalcCyclesStandardDataComReqDto_1.setTargetBelongCycleList(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList().stream().map(item -> BeanUtil.toBean(item, com.wicket.okrcalc.biz.service.dto.common.TargetBelongCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2025245_1_73375
    }

    /*D4执行循环计算不同周期标准数据异常或修订场景(公共)[10290]   */
    Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto_1.getEventBatchUpdateCode(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto_1.getCalcStartTime(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-计算开始时间不能为空",false);
Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto_1.getTargetScoreUnit(),"D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-目标得分单位不能为空",false);
      implementLoopCalcCyclesStandardDataComRespDto_1 = implementLoopCalcCyclesStandardDataCom(implementLoopCalcCyclesStandardDataComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
    }
ImplementCurConBrotherCalcReviseAnormalSceneComRespDto retData = new ImplementCurConBrotherCalcReviseAnormalSceneComRespDto();





return retData;
  }
/**
   * D4执行父级内容向上计算(公共)[10289]
   * gen by moon at 3/8/2025, 12:06:27 AM
   */
  @Trace(operationName = "D4执行父级内容向上计算(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementParentConUpCalcComRespDto implementParentConUpCalcCom(ImplementParentConUpCalcComReqDto reqDto){


      //virtualUsage D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)  73377
      QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = null;
    QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto=new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
  queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2025485_1_73377
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2025486_1_73377
if(reqDto!=null){
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2025496_1_73377
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2025487_1_73377
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2025492_1_73377
    }

    /*D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)[9935]   */
    Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTargetCycleCode(),"D4执行父级内容向上计算(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getCycleStartTime(),"D4执行父级内容向上计算(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-周期开始时间不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaluationTemplateId(),"D4执行父级内容向上计算(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjEntityId(),"D4执行父级内容向上计算(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTypeCode(),"D4执行父级内容向上计算(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-主树被评对象类型编码不能为空",false);
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage M4执行目标归属周期【循环开始】  73378
      //ModelCode: circulationCollections
        for (com.wicket.okrapp.integration.dto.TargetBelongCycleDto circulationCollectionsRes: queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList()){

//virtualUsage D4-1查标准数据详情(公共)  73570
      QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2025588_1_73570
if(circulationCollectionsRes!=null){
      queryStandardDataDetailComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2025587_1_73570
queryStandardDataDetailComReqDto.setThemeContentId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2026166_1_73570
    }

    /*D4-1查标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(),"D4执行父级内容向上计算(公共)-D4-1查标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(),"D4执行父级内容向上计算(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(),"D4执行父级内容向上计算(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataDetailComRespDto = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto)/*vcase invoke isSameApp*/;



if((queryStandardDataDetailComRespDto!= null&& queryStandardDataDetailComRespDto.getDataResultId() != null )) {
        //if(D4-1查标准数据详情(公共).数据结果ID  值不等于空 )  73571

ImplementCalcCurAndAncestorPlanStandardDataComRespDto implementCalcCurAndAncestorPlanStandardDataComRespDto = null;
    ImplementCalcCurAndAncestorPlanStandardDataComReqDto implementCalcCurAndAncestorPlanStandardDataComReqDto=new ImplementCalcCurAndAncestorPlanStandardDataComReqDto();
  implementCalcCurAndAncestorPlanStandardDataComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2025383_1_73572
implementCalcCurAndAncestorPlanStandardDataComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2025384_1_73572
if(circulationCollectionsRes!=null){
      implementCalcCurAndAncestorPlanStandardDataComReqDto.setPreUpdateCycleId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2025387_1_73572
implementCalcCurAndAncestorPlanStandardDataComReqDto.setUpdateCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2025388_1_73572
implementCalcCurAndAncestorPlanStandardDataComReqDto.setUpdateCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:2025389_1_73572
implementCalcCurAndAncestorPlanStandardDataComReqDto.setUpdateCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:2025390_1_73572
implementCalcCurAndAncestorPlanStandardDataComReqDto.setUpdateCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:2025391_1_73572
implementCalcCurAndAncestorPlanStandardDataComReqDto.setIsLastCycle(circulationCollectionsRes.getIsLastCycle());//SimpleFieldAssign//sourceId:2025395_1_73572
implementCalcCurAndAncestorPlanStandardDataComReqDto.setEvaObjTargetCycleCode(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2025385_1_73572
implementCalcCurAndAncestorPlanStandardDataComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType()!=null?String.valueOf(circulationCollectionsRes.getParentSubMidCycleType()):"");//SimpleFieldAssign//sourceId:2025386_1_73572
implementCalcCurAndAncestorPlanStandardDataComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2025382_1_73572
    }
if(reqDto!=null){
      implementCalcCurAndAncestorPlanStandardDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2025392_1_73572
implementCalcCurAndAncestorPlanStandardDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2025393_1_73572
implementCalcCurAndAncestorPlanStandardDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2025394_1_73572
    }

    /*D4执行计算当前及祖先规划标准数据(公共)[9724]   */
    Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getUpdateCycleId(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getUpdateCycleStartTime(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getUpdateCycleEndTime(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getUpdateCycleTypeCode(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getIsLastCycle(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-更新周期是否末级周期不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getEvaObjEntityId(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getEvaObjTypeCode(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-主树被评对象类型编码不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getEvaObjTargetCycleCode(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getParentSubMidCycleType(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getEvaluationTemplateId(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getEventBatchUpdateCode(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getCalcStartTime(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-计算开始时间不能为空",false);
Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getTargetScoreUnit(),"D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-目标得分单位不能为空",false);
      implementCalcCurAndAncestorPlanStandardDataComRespDto = targetCalcService.implementCalcCurAndAncestorPlanStandardDataCom(implementCalcCurAndAncestorPlanStandardDataComReqDto)/*vcase invoke isSameApp*/;



      }
//virtualUsage M4-执行【循环结束】  73379
      //ModelCode: circulationEnd
        }

ImplementParentConUpCalcComRespDto retData = new ImplementParentConUpCalcComRespDto();





return retData;
  }
/**
   * D4执行循环计算不同周期标准数据异常或修订场景(公共)[10290]
   * gen by moon at 12/3/2024, 11:40:21 AM
   */
  @Trace(operationName = "D4执行循环计算不同周期标准数据异常或修订场景(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementLoopCalcCyclesStandardDataComRespDto implementLoopCalcCyclesStandardDataCom(ImplementLoopCalcCyclesStandardDataComReqDto reqDto){


      //virtualUsage M4执行目标归属周期【循环开始】  73363
      //ModelCode: circulationCollections
        for (com.wicket.okrcalc.biz.service.dto.common.TargetBelongCycleDto circulationCollectionsRes: reqDto.getTargetBelongCycleList()){

//virtualUsage D4-1查标准数据详情(公共)  73364
            QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    com.wicket.okrcalc.biz.service.dto.req.QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2025238_1_73364
if(circulationCollectionsRes!=null){
      queryStandardDataDetailComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2025236_1_73364
queryStandardDataDetailComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:2025237_1_73364
    }

    /*D4-1查标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataDetailComRespDto = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto)/*vcase invoke isSameApp*/;



if((queryStandardDataDetailComRespDto!= null&& queryStandardDataDetailComRespDto.getDataResultId() != null )) {
        //if(D4-1查当前内容当前周期当前有效的标准数据（用于判断需不需要进入计算）.数据结果ID  值不等于空 )  73365

ImplementCurOrAncestorContentCalcStandardDataComRespDto implementCurOrAncestorContentCalcStandardDataComRespDto = null;
    ImplementCurOrAncestorContentCalcStandardDataComReqDto implementCurOrAncestorContentCalcStandardDataComReqDto=new ImplementCurOrAncestorContentCalcStandardDataComReqDto();
  implementCurOrAncestorContentCalcStandardDataComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2025370_1_73376
if(circulationCollectionsRes!=null){
      implementCurOrAncestorContentCalcStandardDataComReqDto.setLastCycleCalcModelId(circulationCollectionsRes.getLastCycleCalcModelId());//SimpleFieldAssign//sourceId:2025360_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setProcessCycleCalcModelId(circulationCollectionsRes.getProcessCycleCalcModelId());//SimpleFieldAssign//sourceId:2025361_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setSubCycleCalcModelId(circulationCollectionsRes.getSubCycleCalcModelId());//SimpleFieldAssign//sourceId:2025362_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setMidCycleCalcModelId(circulationCollectionsRes.getMidCycleCalcModelId());//SimpleFieldAssign//sourceId:2025363_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setParentCycleCalcModelId(circulationCollectionsRes.getParentCycleCalcModelId());//SimpleFieldAssign//sourceId:2025364_1_73376
      implementCurOrAncestorContentCalcStandardDataComReqDto.setPreUpdateCycleId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2025365_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setUpdateCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2025366_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setUpdateCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:2025367_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setUpdateCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:2025368_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setUpdateCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:2025369_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setIsLastCycle(circulationCollectionsRes.getIsLastCycle());//SimpleFieldAssign//sourceId:2025374_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2025375_1_73376
    }
if(reqDto!=null){
implementCurOrAncestorContentCalcStandardDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2025371_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2025372_1_73376
implementCurOrAncestorContentCalcStandardDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2025373_1_73376
    }

    /*D4执行当前或祖先内容计算目标标准数据(公共)[9733]   */
    Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getUpdateCycleId(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getUpdateCycleStartTime(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getUpdateCycleEndTime(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getUpdateCycleTypeCode(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getIsLastCycle(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-更新周期是否末级周期不能为空",false);
Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getEvaluationTemplateId(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getSpaceId(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getEventBatchUpdateCode(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getCalcStartTime(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-计算开始时间不能为空",false);
Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getTargetScoreUnit(),"D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-目标得分单位不能为空",false);
      implementCurOrAncestorContentCalcStandardDataComRespDto = targetCalcService.implementCurOrAncestorContentCalcStandardDataCom(implementCurOrAncestorContentCalcStandardDataComReqDto)/*vcase invoke isSameApp*/;



      }
//virtualUsage M4-执行【循环结束】  73367
      //ModelCode: circulationEnd
        }

ImplementLoopCalcCyclesStandardDataComRespDto retData = new ImplementLoopCalcCyclesStandardDataComRespDto();





return retData;
  }
/**
   * D4分析数据计算正常与异常场景(公共)[10291]
   * gen by moon at 10/30/2024, 10:06:22 PM
   */
  @Trace(operationName = "D4分析数据计算正常与异常场景(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisDataCalcNormalAndAmSceneComRespDto analysisDataCalcNormalAndAmSceneCom(AnalysisDataCalcNormalAndAmSceneComReqDto reqDto){


      AnalysisDataCalcNormalAmSceneComRespDto analysisDataCalcNormalAmSceneComRespDto_1 =null;
//步骤0: D3分析数据计算正常场景中的正常与异常(公共) - analysisDataCalcNormalAmSceneCom
     AnalysisDataCalcNormalAmSceneComRespDto analysisDataCalcNormalAmSceneComRespDto = null;
    AnalysisDataCalcNormalAmSceneComReqDto analysisDataCalcNormalAmSceneComReqDto=new AnalysisDataCalcNormalAmSceneComReqDto();
  if(reqDto!=null){
      analysisDataCalcNormalAmSceneComReqDto.setDataCalcNormalAbnormal(reqDto.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2025626_1
analysisDataCalcNormalAmSceneComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2025623_1
analysisDataCalcNormalAmSceneComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2025624_1
    }

    /*D3分析数据计算正常场景中的正常与异常(公共)[10284]   */
    Assert.isNull(analysisDataCalcNormalAmSceneComReqDto.getDataCalcNormalAbnormal(),"D4分析数据计算正常与异常场景(公共)-D3分析数据计算正常场景中的正常与异常(公共)-数据计算正常与异常场景不能为空",false);
Assert.isNull(analysisDataCalcNormalAmSceneComReqDto.getCycleId(),"D4分析数据计算正常与异常场景(公共)-D3分析数据计算正常场景中的正常与异常(公共)-周期ID不能为空",false);
Assert.isNull(analysisDataCalcNormalAmSceneComReqDto.getEvaluationTemplateId(),"D4分析数据计算正常与异常场景(公共)-D3分析数据计算正常场景中的正常与异常(公共)-冗余评价模板ID不能为空",false);
      analysisDataCalcNormalAmSceneComRespDto = fwAppEvaCalcClient.analysisDataCalcNormalAmSceneCom(analysisDataCalcNormalAmSceneComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      analysisDataCalcNormalAmSceneComRespDto_1 = analysisDataCalcNormalAmSceneComRespDto;

AnalysisDataCalcNormalAndAmSceneComRespDto retData = new AnalysisDataCalcNormalAndAmSceneComRespDto();
  if(analysisDataCalcNormalAmSceneComRespDto_1!=null){
      retData.setDataCalcNormalAbnormal(analysisDataCalcNormalAmSceneComRespDto_1.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2025630_1
    }




return retData;
  }
/**
   * D4执行计算克隆向右非末级周期标准数据(公共)[10415]
   * gen by moon at 12/5/2024, 11:01:31 PM
   */
  @Trace(operationName = "D4执行计算克隆向右非末级周期标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCalcCurRightCycleStandardDataComRespDto implementCalcCurRightCycleStandardDataCom(ImplementCalcCurRightCycleStandardDataComReqDto reqDto){


      ImplementCalcReceivingField006RespDto receptionServiceRes_1 =null;
//virtualUsage D3分析克隆非末级周期进入条件(公共)  73648
      AnalysisCloneNoLastCycleEnterConditionComRespDto analysisCloneNoLastCycleEnterConditionComRespDto = null;
    AnalysisCloneNoLastCycleEnterConditionComReqDto analysisCloneNoLastCycleEnterConditionComReqDto=new AnalysisCloneNoLastCycleEnterConditionComReqDto();
  if(reqDto!=null){
      analysisCloneNoLastCycleEnterConditionComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2033288_1_73648
analysisCloneNoLastCycleEnterConditionComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2033289_1_73648
analysisCloneNoLastCycleEnterConditionComReqDto.setOwnEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2033290_1_73648
analysisCloneNoLastCycleEnterConditionComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2033291_1_73648
    }

    /*D3分析克隆非末级周期进入条件(公共)[10416]   */
    Assert.isNull(analysisCloneNoLastCycleEnterConditionComReqDto.getUpdateCycleId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3分析克隆非末级周期进入条件(公共)-更新周期ID不能为空",false);
Assert.isNull(analysisCloneNoLastCycleEnterConditionComReqDto.getCycleId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3分析克隆非末级周期进入条件(公共)-归属周期ID不能为空",false);
Assert.isNull(analysisCloneNoLastCycleEnterConditionComReqDto.getOwnEntityId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3分析克隆非末级周期进入条件(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(analysisCloneNoLastCycleEnterConditionComReqDto.getEvaluationTemplateId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3分析克隆非末级周期进入条件(公共)-冗余评价模板ID不能为空",false);
      analysisCloneNoLastCycleEnterConditionComRespDto = fwAppEvaCalcClient.analysisCloneNoLastCycleEnterConditionCom(analysisCloneNoLastCycleEnterConditionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((analysisCloneNoLastCycleEnterConditionComRespDto!= null&&  analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType() !=null && analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType().equals("RECYCLE_CLONE"))) {
        //if(D3分析克隆非末级周期进入条件(公共).非末级周期克隆类型 等于 最近可循环克隆)  73649

CalculateFinalObjectiveScoreComRespDto calculateFinalObjectiveScoreComRespDto = null;
    CalculateFinalObjectiveScoreComReqDto calculateFinalObjectiveScoreComReqDto=new CalculateFinalObjectiveScoreComReqDto();
  calculateFinalObjectiveScoreComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2033493_1_73665
if(reqDto!=null){
      calculateFinalObjectiveScoreComReqDto.setTargetAttributionCycleId(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:2033503_1_73665
calculateFinalObjectiveScoreComReqDto.setReportScoreCountFormula(reqDto.getReportScoreCountFormula());//SimpleFieldAssign//sourceId:2033494_1_73665
calculateFinalObjectiveScoreComReqDto.setSubAndObjModel(reqDto.getSubAndObjModel());//SimpleFieldAssign//sourceId:2033490_1_73665
calculateFinalObjectiveScoreComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2033504_1_73665
calculateFinalObjectiveScoreComReqDto.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2033505_1_73665
calculateFinalObjectiveScoreComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:2033496_1_73665
calculateFinalObjectiveScoreComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:2033495_1_73665
calculateFinalObjectiveScoreComReqDto.setTargetValueType(reqDto.getTargetValueType());//SimpleFieldAssign//sourceId:2033491_1_73665
calculateFinalObjectiveScoreComReqDto.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:2033501_1_73665
calculateFinalObjectiveScoreComReqDto.setEvaTargetStartValue(reqDto.getEvaTargetStartValue());//SimpleFieldAssign//sourceId:2033498_1_73665
calculateFinalObjectiveScoreComReqDto.setEvaTargetValue(reqDto.getEvaTargetValue());//SimpleFieldAssign//sourceId:2033499_1_73665
calculateFinalObjectiveScoreComReqDto.setEvaTargetDiagnosticValue(reqDto.getEvaTargetDiagnosticValue());//SimpleFieldAssign//sourceId:2033500_1_73665
calculateFinalObjectiveScoreComReqDto.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:2033497_1_73665
calculateFinalObjectiveScoreComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2033492_1_73665
    }

    /*D3计算指标最终客观得分(公共)[9442]   */
    Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetAttributionCycleId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-目标归属周期ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getUpdateCycleId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-更新周期ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getEvaObjTargetCycleId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetCycleContentTypeCode(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetCycleContentId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getWeightScore(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-权重分值不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getEvaluationTemplateId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto.getSpaceId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-创建于空间ID不能为空",false);
      calculateFinalObjectiveScoreComRespDto = fwAppTargetCalcClient.calculateFinalObjectiveScoreCom(calculateFinalObjectiveScoreComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//ModelCode: receptionService
        ImplementCalcReceivingField006RespDto receptionServiceRes = null;
    if(calculateFinalObjectiveScoreComRespDto !=null){
          ImplementCalcReceivingField006ReqDto receptionServiceReq=new ImplementCalcReceivingField006ReqDto();
  if(reqDto!=null){
      receptionServiceReq.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:2033381_1_73655
receptionServiceReq.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:2033382_1_73655
    }
if(calculateFinalObjectiveScoreComRespDto!=null){
      receptionServiceReq.setObjectiveScore(calculateFinalObjectiveScoreComRespDto.getObjectiveScore());//SimpleFieldAssign//sourceId:2033506_1_73655
    }

    /*M4接收出参字段：进度值、实际值、客观得分[9540]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((analysisCloneNoLastCycleEnterConditionComRespDto!= null&&  analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType() !=null && analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType().equals("ACTUAL_CLONE"))){
       //elseif(D3分析克隆非末级周期进入条件(公共).非末级周期克隆类型 等于 提前实际验收克隆)  73652

QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto = null;
    QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto=new QueryStandardDataOfObjectDetailComReqDto();
  queryStandardDataOfObjectDetailComReqDto.setDataType("PROGRESS_VALUE");//sourceId:2033405_1_73656
queryStandardDataOfObjectDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2033422_1_73656
queryStandardDataOfObjectDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2033427_1_73656
if(reqDto!=null){
      queryStandardDataOfObjectDetailComReqDto.setPeriodId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2033406_1_73656
queryStandardDataOfObjectDetailComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2033409_1_73656
queryStandardDataOfObjectDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2033410_1_73656
    }

    /*D4查询进度值归属主体标准数据详情(公共)[8850]   */
    Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getDataType(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-数据点类型不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getPeriodId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getEntityId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getThemeContentId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getDataUsageSceneCode(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getSubjectLifeCycle(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataOfObjectDetailComRespDto = standardDataService.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto)/*vcase invoke isSameApp*/;



if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
        //if(D4执行克隆向右非末级周期标准数据(公共).关联目标内容类型编码 等于 指标)  73659

QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto_2 = null;
    QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto_1=new QueryStandardDataOfObjectDetailComReqDto();
  queryStandardDataOfObjectDetailComReqDto_1.setDataType("ACTUAL_VALUE");//sourceId:2033440_1_73660
queryStandardDataOfObjectDetailComReqDto_1.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2033457_1_73660
queryStandardDataOfObjectDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2033462_1_73660
if(reqDto!=null){
      queryStandardDataOfObjectDetailComReqDto_1.setPeriodId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2033441_1_73660
queryStandardDataOfObjectDetailComReqDto_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2033477_1_73660
queryStandardDataOfObjectDetailComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2033445_1_73660
    }

    /*D4查询实际值归属主体标准数据详情(公共)[8850]   */
    Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getDataType(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-数据点类型不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getPeriodId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getEntityId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getThemeContentId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getDataUsageSceneCode(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getSubjectLifeCycle(),"D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataOfObjectDetailComRespDto_2 = standardDataService.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto_1)/*vcase invoke isSameApp*/;



CalculateFinalObjectiveScoreComRespDto calculateFinalObjectiveScoreComRespDto_2 = null;
    if(queryStandardDataOfObjectDetailComRespDto_2 !=null){
          CalculateFinalObjectiveScoreComReqDto calculateFinalObjectiveScoreComReqDto_1=new CalculateFinalObjectiveScoreComReqDto();
  calculateFinalObjectiveScoreComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2033493_1_73664
if(reqDto!=null){
      calculateFinalObjectiveScoreComReqDto_1.setTargetAttributionCycleId(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:2033503_1_73664
calculateFinalObjectiveScoreComReqDto_1.setReportScoreCountFormula(reqDto.getReportScoreCountFormula());//SimpleFieldAssign//sourceId:2033494_1_73664
calculateFinalObjectiveScoreComReqDto_1.setSubAndObjModel(reqDto.getSubAndObjModel());//SimpleFieldAssign//sourceId:2033490_1_73664
calculateFinalObjectiveScoreComReqDto_1.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2033504_1_73664
calculateFinalObjectiveScoreComReqDto_1.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2033505_1_73664
calculateFinalObjectiveScoreComReqDto_1.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:2033496_1_73664
calculateFinalObjectiveScoreComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:2033495_1_73664
calculateFinalObjectiveScoreComReqDto_1.setTargetValueType(reqDto.getTargetValueType());//SimpleFieldAssign//sourceId:2033491_1_73664
calculateFinalObjectiveScoreComReqDto_1.setEvaTargetStartValue(reqDto.getEvaTargetStartValue());//SimpleFieldAssign//sourceId:2033498_1_73664
calculateFinalObjectiveScoreComReqDto_1.setEvaTargetValue(reqDto.getEvaTargetValue());//SimpleFieldAssign//sourceId:2033499_1_73664
calculateFinalObjectiveScoreComReqDto_1.setEvaTargetDiagnosticValue(reqDto.getEvaTargetDiagnosticValue());//SimpleFieldAssign//sourceId:2033500_1_73664
calculateFinalObjectiveScoreComReqDto_1.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:2033497_1_73664
calculateFinalObjectiveScoreComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2033492_1_73664
    }
if(queryStandardDataOfObjectDetailComRespDto_2!=null){
      calculateFinalObjectiveScoreComReqDto_1.setActualValue(queryStandardDataOfObjectDetailComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:2033501_1_73664
    }

    /*D3计算指标最终客观得分(公共)[9442]   */
    Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getTargetAttributionCycleId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-目标归属周期ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getUpdateCycleId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-更新周期ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getEvaObjTargetCycleId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getTargetCycleContentTypeCode(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getTargetCycleContentId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getWeightScore(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-权重分值不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getEvaluationTemplateId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getSpaceId(),"D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-创建于空间ID不能为空",false);
      calculateFinalObjectiveScoreComRespDto_2 = fwAppTargetCalcClient.calculateFinalObjectiveScoreCom(calculateFinalObjectiveScoreComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        ImplementCalcReceivingField006RespDto receptionServiceRes_2 = null;
    if(queryStandardDataOfObjectDetailComRespDto !=null&&queryStandardDataOfObjectDetailComRespDto_2 !=null&&calculateFinalObjectiveScoreComRespDto_2 !=null){
          ImplementCalcReceivingField006ReqDto receptionServiceReq_1=new ImplementCalcReceivingField006ReqDto();
  if(queryStandardDataOfObjectDetailComRespDto!=null){
      receptionServiceReq_1.setProgressValue(queryStandardDataOfObjectDetailComRespDto.getDataResult());//SimpleFieldAssign//sourceId:2033381_1_73663
    }
if(queryStandardDataOfObjectDetailComRespDto_2!=null){
      receptionServiceReq_1.setActualValue(queryStandardDataOfObjectDetailComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:2033382_1_73663
    }
if(calculateFinalObjectiveScoreComRespDto_2!=null){
      receptionServiceReq_1.setObjectiveScore(calculateFinalObjectiveScoreComRespDto_2.getObjectiveScore());//SimpleFieldAssign//sourceId:2033506_1_73663
    }

    /*M4接收出参字段：进度值、实际值、客观得分[9540]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
      }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET")||reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY"))){
       //elseif((D4执行克隆向右非末级周期标准数据(公共).关联目标内容类型编码 等于 目标 or D4执行克隆向右非末级周期标准数据(公共).关联目标内容类型编码 等于 目标分类))  73661

//ModelCode: receptionService
        ImplementCalcReceivingField006RespDto receptionServiceRes_3 = null;
    if(queryStandardDataOfObjectDetailComRespDto !=null){
          ImplementCalcReceivingField006ReqDto receptionServiceReq_2=new ImplementCalcReceivingField006ReqDto();
  if(queryStandardDataOfObjectDetailComRespDto!=null){
      receptionServiceReq_2.setProgressValue(queryStandardDataOfObjectDetailComRespDto.getDataResult());//SimpleFieldAssign//sourceId:2033381_1_73662
    }

    /*M4接收出参字段：进度值、实际值、客观得分[9540]  用于特殊方法接收上游入参。 */

      receptionServiceRes_3 = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
    }
    }
else if((analysisCloneNoLastCycleEnterConditionComRespDto!= null&&  analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType() !=null && analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType().equals("NO_CLONE"))){
       //elseif(D3分析克隆非末级周期进入条件(公共).非末级周期克隆类型 等于 不克隆)  73653

//processBranchName:正常结束 ,processBranchId:73654

    }
ImplementCalcCurRightCycleStandardDataComRespDto retData = new ImplementCalcCurRightCycleStandardDataComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setProgressValue(receptionServiceRes_1.getProgressValue());//SimpleFieldAssign//sourceId:2033484_1
retData.setActualValue(receptionServiceRes_1.getActualValue());//SimpleFieldAssign//sourceId:2033485_1
retData.setObjectiveScore(receptionServiceRes_1.getObjectiveScore());//SimpleFieldAssign//sourceId:2033531_1
    }




return retData;
  }
/**
   * D4执行MQ计算当前或祖先规划目标标准数据(公共)[10501]
   * gen by moon at 3/6/2025, 10:13:58 PM
   */
  @Trace(operationName = "D4执行MQ计算当前或祖先规划目标标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCalcCurOrParentTargetDataComRespDto implementCalcCurOrParentTargetDataCom(ImplementCalcCurOrParentTargetDataComReqDto reqDto){


      if((reqDto!= null&& reqDto.getLastCycleCalcModelId() != null )) {
        //if(D4执行MQ计算当前或祖先规划目标标准数据(公共).末级周期计算模型ID 值不等于空 )  73886

ImplementEvaObjCurrentAndSupCountFormulasComRespDto implementEvaObjCurrentAndSupCountFormulasComRespDto = null;
    ImplementEvaObjCurrentAndSupCountFormulasComReqDto implementEvaObjCurrentAndSupCountFormulasComReqDto=new ImplementEvaObjCurrentAndSupCountFormulasComReqDto();
  if(reqDto!=null){
      implementEvaObjCurrentAndSupCountFormulasComReqDto.setTargetAttributionCycleId(reqDto.getLastCycleCalcModelId());//SimpleFieldAssign//sourceId:2040252_1_73895
implementEvaObjCurrentAndSupCountFormulasComReqDto.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040260_1_73895
implementEvaObjCurrentAndSupCountFormulasComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040253_1_73895
implementEvaObjCurrentAndSupCountFormulasComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040254_1_73895
implementEvaObjCurrentAndSupCountFormulasComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040255_1_73895
implementEvaObjCurrentAndSupCountFormulasComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040256_1_73895
implementEvaObjCurrentAndSupCountFormulasComReqDto.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040261_1_73895
implementEvaObjCurrentAndSupCountFormulasComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2040251_1_73895
implementEvaObjCurrentAndSupCountFormulasComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040257_1_73895
implementEvaObjCurrentAndSupCountFormulasComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040258_1_73895
implementEvaObjCurrentAndSupCountFormulasComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040259_1_73895
    }

    /*D4执行评价对象树当前与上级公式计算(公共)[8736]   */
    Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getTargetAttributionCycleId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标归属周期ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getUpdateCycleId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getUpdateCycleStartTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getUpdateCycleEndTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getUpdateCycleTypeCode(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getIsLastCycle(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-是否末级周期不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getSpaceId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getEventBatchUpdateCode(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getCalcStartTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-计算开始时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getTargetScoreUnit(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标得分单位不能为空",false);
      implementEvaObjCurrentAndSupCountFormulasComRespDto = targetCalcService.implementEvaObjCurrentAndSupCountFormulasCom(implementEvaObjCurrentAndSupCountFormulasComReqDto)/*vcase invoke isSameApp*/;



      }
if((reqDto!= null&& reqDto.getProcessCycleCalcModelId() != null )) {
        //if(D4执行MQ计算当前或祖先规划目标标准数据(公共).过程中间周期计算模型ID 值不等于空 )  73888

ImplementEvaObjCurrentAndSupCountFormulasComRespDto implementEvaObjCurrentAndSupCountFormulasComRespDto_1 = null;
    ImplementEvaObjCurrentAndSupCountFormulasComReqDto implementEvaObjCurrentAndSupCountFormulasComReqDto_1=new ImplementEvaObjCurrentAndSupCountFormulasComReqDto();
  if(reqDto!=null){
      implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setTargetAttributionCycleId(reqDto.getProcessCycleCalcModelId());//SimpleFieldAssign//sourceId:2040252_1_73896
implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040260_1_73896
implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040253_1_73896
implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040254_1_73896
implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040255_1_73896
implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040256_1_73896
implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040261_1_73896
implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2040251_1_73896
implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040257_1_73896
implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040258_1_73896
implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040259_1_73896
    }

    /*D4执行评价对象树当前与上级公式计算(公共)[8736]   */
    Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getTargetAttributionCycleId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标归属周期ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getUpdateCycleId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getUpdateCycleStartTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getUpdateCycleEndTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getUpdateCycleTypeCode(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getIsLastCycle(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-是否末级周期不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getSpaceId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getEventBatchUpdateCode(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getCalcStartTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-计算开始时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getTargetScoreUnit(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标得分单位不能为空",false);
      implementEvaObjCurrentAndSupCountFormulasComRespDto_1 = targetCalcService.implementEvaObjCurrentAndSupCountFormulasCom(implementEvaObjCurrentAndSupCountFormulasComReqDto_1)/*vcase invoke isSameApp*/;



      }
if((reqDto!= null&& reqDto.getSubCycleCalcModelId() != null )) {
        //if(D4执行MQ计算当前或祖先规划目标标准数据(公共).子周期计算模型ID 值不等于空 )  73890

ImplementEvaObjCurrentAndSupCountFormulasComRespDto implementEvaObjCurrentAndSupCountFormulasComRespDto_2 = null;
    ImplementEvaObjCurrentAndSupCountFormulasComReqDto implementEvaObjCurrentAndSupCountFormulasComReqDto_2=new ImplementEvaObjCurrentAndSupCountFormulasComReqDto();
  if(reqDto!=null){
      implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setTargetAttributionCycleId(reqDto.getSubCycleCalcModelId());//SimpleFieldAssign//sourceId:2040252_1_73897
implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040260_1_73897
implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040253_1_73897
implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040254_1_73897
implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040255_1_73897
implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040256_1_73897
implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040261_1_73897
implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2040251_1_73897
implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040257_1_73897
implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040258_1_73897
implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040259_1_73897
    }

    /*D4执行评价对象树当前与上级公式计算(公共)[8736]   */
    Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getTargetAttributionCycleId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标归属周期ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getUpdateCycleId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getUpdateCycleStartTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getUpdateCycleEndTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getUpdateCycleTypeCode(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getIsLastCycle(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-是否末级周期不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getSpaceId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getEventBatchUpdateCode(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getCalcStartTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-计算开始时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getTargetScoreUnit(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标得分单位不能为空",false);
      implementEvaObjCurrentAndSupCountFormulasComRespDto_2 = targetCalcService.implementEvaObjCurrentAndSupCountFormulasCom(implementEvaObjCurrentAndSupCountFormulasComReqDto_2)/*vcase invoke isSameApp*/;



      }
if((reqDto!= null&& reqDto.getMidCycleCalcModelId() != null )) {
        //if(D4执行MQ计算当前或祖先规划目标标准数据(公共).中期计算模型ID 值不等于空 )  73892

ImplementEvaObjCurrentAndSupCountFormulasComRespDto implementEvaObjCurrentAndSupCountFormulasComRespDto_3 = null;
    ImplementEvaObjCurrentAndSupCountFormulasComReqDto implementEvaObjCurrentAndSupCountFormulasComReqDto_3=new ImplementEvaObjCurrentAndSupCountFormulasComReqDto();
  if(reqDto!=null){
      implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setTargetAttributionCycleId(reqDto.getMidCycleCalcModelId());//SimpleFieldAssign//sourceId:2040252_1_73898
implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040260_1_73898
implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040253_1_73898
implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040254_1_73898
implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040255_1_73898
implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040256_1_73898
implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040261_1_73898
implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2040251_1_73898
implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040257_1_73898
implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040258_1_73898
implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040259_1_73898
    }

    /*D4执行评价对象树当前与上级公式计算(公共)[8736]   */
    Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getTargetAttributionCycleId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标归属周期ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getUpdateCycleId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getUpdateCycleStartTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getUpdateCycleEndTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getUpdateCycleTypeCode(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getIsLastCycle(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-是否末级周期不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getSpaceId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getEventBatchUpdateCode(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getCalcStartTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-计算开始时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getTargetScoreUnit(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标得分单位不能为空",false);
      implementEvaObjCurrentAndSupCountFormulasComRespDto_3 = targetCalcService.implementEvaObjCurrentAndSupCountFormulasCom(implementEvaObjCurrentAndSupCountFormulasComReqDto_3)/*vcase invoke isSameApp*/;



      }
if((reqDto!= null&& reqDto.getParentCycleCalcModelId() != null )) {
        //if(D4执行MQ计算当前或祖先规划目标标准数据(公共).父周期计算模型ID 值不等于空 )  73894

ImplementEvaObjCurrentAndSupCountFormulasComRespDto implementEvaObjCurrentAndSupCountFormulasComRespDto_4 = null;
    ImplementEvaObjCurrentAndSupCountFormulasComReqDto implementEvaObjCurrentAndSupCountFormulasComReqDto_4=new ImplementEvaObjCurrentAndSupCountFormulasComReqDto();
  if(reqDto!=null){
      implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setTargetAttributionCycleId(reqDto.getParentCycleCalcModelId());//SimpleFieldAssign//sourceId:2040252_1_73899
implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040260_1_73899
implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040253_1_73899
implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040254_1_73899
implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040255_1_73899
implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040256_1_73899
implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040261_1_73899
implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2040251_1_73899
implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040257_1_73899
implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040258_1_73899
implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040259_1_73899
    }

    /*D4执行评价对象树当前与上级公式计算(公共)[8736]   */
    Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getTargetAttributionCycleId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标归属周期ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getUpdateCycleId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getUpdateCycleStartTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getUpdateCycleEndTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getUpdateCycleTypeCode(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getIsLastCycle(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-是否末级周期不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getSpaceId(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getEventBatchUpdateCode(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getCalcStartTime(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-计算开始时间不能为空",false);
Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getTargetScoreUnit(),"D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标得分单位不能为空",false);
      implementEvaObjCurrentAndSupCountFormulasComRespDto_4 = targetCalcService.implementEvaObjCurrentAndSupCountFormulasCom(implementEvaObjCurrentAndSupCountFormulasComReqDto_4)/*vcase invoke isSameApp*/;



      }
ImplementCalcCurOrParentTargetDataComRespDto retData = new ImplementCalcCurOrParentTargetDataComRespDto();





return retData;
  }
/**
   * D4执行MQ计算当前及祖先规划目标标准数据(公共)[10502]
   * gen by moon at 3/8/2025, 4:16:21 PM
   */
  @Trace(operationName = "D4执行MQ计算当前及祖先规划目标标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCalcCurAndParentTargetDataComRespDto implementCalcCurAndParentTargetDataCom(ImplementCalcCurAndParentTargetDataComReqDto reqDto){


      //步骤0: D4执行计算公共接收字段(公共) - implementCalcReceiveFieldCom
     ImplementCalcReceiveFieldComRespDto implementCalcReceiveFieldComRespDto = null;
    ImplementCalcReceiveFieldComReqDto implementCalcReceiveFieldComReqDto=new ImplementCalcReceiveFieldComReqDto();
  if(reqDto!=null){
      implementCalcReceiveFieldComReqDto.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040295_1
implementCalcReceiveFieldComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040296_1
implementCalcReceiveFieldComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040297_1
implementCalcReceiveFieldComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040298_1
implementCalcReceiveFieldComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040299_1
implementCalcReceiveFieldComReqDto.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040305_1
implementCalcReceiveFieldComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2040280_1
implementCalcReceiveFieldComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2040281_1
implementCalcReceiveFieldComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2040282_1
implementCalcReceiveFieldComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2040286_1
implementCalcReceiveFieldComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040279_1
implementCalcReceiveFieldComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040284_1
implementCalcReceiveFieldComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040294_1
implementCalcReceiveFieldComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040301_1
    }

    /*D4执行计算公共接收字段(公共)[9726]   */
    Assert.isNull(implementCalcReceiveFieldComReqDto.getUpdateCycleId(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-更新周期ID不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getUpdateCycleStartTime(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getUpdateCycleEndTime(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getUpdateCycleTypeCode(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getIsLastCycle(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-是否末级周期不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getEvaObjEntityId(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getEvaObjTypeCode(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-主树被评对象类型编码不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getEvaObjTargetCycleCode(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getParentSubMidCycleType(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getEvaluationTemplateId(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getEventBatchUpdateCode(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getCalcStartTime(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-计算开始时间不能为空",false);
Assert.isNull(implementCalcReceiveFieldComReqDto.getTargetScoreUnit(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-目标得分单位不能为空",false);
      implementCalcReceiveFieldComRespDto = divineDataService.implementCalcReceiveFieldCom(implementCalcReceiveFieldComReqDto)/*vcase invoke isSameApp*/;




//步骤1: D3查询当前及祖先列表(公共) - queryCurAndAncestorListCom
     QueryCurAndAncestorListComRespDto queryCurAndAncestorListComRespDto = null;
    QueryCurAndAncestorListComReqDto queryCurAndAncestorListComReqDto=new QueryCurAndAncestorListComReqDto();
  if(reqDto!=null){
      queryCurAndAncestorListComReqDto.setComCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2040310_1
    }

    /*D3查询当前及祖先列表(公共)[9727]   */
    Assert.isNull(queryCurAndAncestorListComReqDto.getComCode(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查询当前及祖先列表(公共)-通用编码标识不能为空",false);
      queryCurAndAncestorListComRespDto = fwAppTargetCalcClient.queryCurAndAncestorListCom(queryCurAndAncestorListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤2: D3批量查询目标归属周期by被评对象目标周期标识（双排序）(公共) - batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeCom
     BatchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComRespDto batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComRespDto = null;
    if(queryCurAndAncestorListComRespDto !=null){
          BatchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto=new BatchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto();
  if(queryCurAndAncestorListComRespDto!=null){
      batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setTargetBelongCycleList(queryCurAndAncestorListComRespDto.getCurAndAncestorList());//list-field-assign//sourceId:2040313_1
    }
if(reqDto!=null){
      batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040318_1
batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040319_1
batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040320_1
batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2040314_1
batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2040315_1
batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2040316_1
batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040317_1
    }

    /*D3查当前及祖先目标归属周期列表(公共)[9730]   */
    Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getCycleStartTime(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-周期开始时间不能为空",false);
Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getCycleEndTime(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-周期结束时间不能为空",false);
Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getCycleTypeCode(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-周期类型标识不能为空",false);
Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getEvaObjEntityId(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getEvaObjTypeCode(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-主树被评对象类型编码不能为空",false);
Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getParentSubMidCycleType(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getEvaluationTemplateId(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-冗余评价模板ID不能为空",false);
      batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComRespDto = fwAppTargetCalcClient.batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeCom(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

//步骤3: M4执行目标归属周期【循环开始】 - implementTargetAttributionCycleLoopStart
     //ModelCode: circulationCollections
        for (com.wicket.okrapp.integration.dto.TargetBelongCycleDto circulationCollectionsRes: batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComRespDto.getTargetBelongCycleList()){


//步骤4: D4执行MQ计算当前或祖先规划目标标准数据(公共) - implementCalcCurOrParentTargetDataCom
     ImplementCalcCurOrParentTargetDataComRespDto implementCalcCurOrParentTargetDataComRespDto = null;
    ImplementCalcCurOrParentTargetDataComReqDto implementCalcCurOrParentTargetDataComReqDto=new ImplementCalcCurOrParentTargetDataComReqDto();
  implementCalcCurOrParentTargetDataComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2040419_1
if(circulationCollectionsRes!=null){
      implementCalcCurOrParentTargetDataComReqDto.setLastCycleCalcModelId(circulationCollectionsRes.getLastCycleCalcModelId());//SimpleFieldAssign//sourceId:2040423_1
implementCalcCurOrParentTargetDataComReqDto.setProcessCycleCalcModelId(circulationCollectionsRes.getProcessCycleCalcModelId());//SimpleFieldAssign//sourceId:2040424_1
implementCalcCurOrParentTargetDataComReqDto.setSubCycleCalcModelId(circulationCollectionsRes.getSubCycleCalcModelId());//SimpleFieldAssign//sourceId:2040409_1
implementCalcCurOrParentTargetDataComReqDto.setMidCycleCalcModelId(circulationCollectionsRes.getMidCycleCalcModelId());//SimpleFieldAssign//sourceId:2040410_1
implementCalcCurOrParentTargetDataComReqDto.setParentCycleCalcModelId(circulationCollectionsRes.getParentCycleCalcModelId());//SimpleFieldAssign//sourceId:2040411_1
    }
if(reqDto!=null){
      implementCalcCurOrParentTargetDataComReqDto.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040412_1
implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040413_1
implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040414_1
implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040415_1
implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040416_1
implementCalcCurOrParentTargetDataComReqDto.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040417_1
implementCalcCurOrParentTargetDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040418_1
implementCalcCurOrParentTargetDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040420_1
implementCalcCurOrParentTargetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040421_1
implementCalcCurOrParentTargetDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040422_1
    }

    /*D4执行MQ计算当前或祖先规划目标标准数据(公共)[10501]   */
    Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleId(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleStartTime(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleEndTime(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleTypeCode(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getIsLastCycle(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期是否末级周期不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getEvaluationTemplateId(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getSpaceId(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getEventBatchUpdateCode(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getCalcStartTime(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-计算开始时间不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getTargetScoreUnit(),"D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-目标得分单位不能为空",false);
      implementCalcCurOrParentTargetDataComRespDto = implementCalcCurOrParentTargetDataCom(implementCalcCurOrParentTargetDataComReqDto)/*vcase invoke 同服务,同domain*/;




//步骤5: M4-执行【循环结束】 - implementLoopStopCalc
     //ModelCode: circulationEnd
        }


ImplementCalcCurAndParentTargetDataComRespDto retData = new ImplementCalcCurAndParentTargetDataComRespDto();





return retData;
  }
/**
   * D4执行MQ循环计算规划目标数据异常或修订场景(公共)[10503]
   * gen by moon at 3/6/2025, 10:14:27 PM
   */
  @Trace(operationName = "D4执行MQ循环计算规划目标数据异常或修订场景(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementLoopCalcCyclesTargetDataComRespDto implementLoopCalcCyclesTargetDataCom(ImplementLoopCalcCyclesTargetDataComReqDto reqDto){


      //virtualUsage M4执行目标归属周期【循环开始】  73903
      //ModelCode: circulationCollections
        for (TargetBelongCycleDto circulationCollectionsRes: reqDto.getTargetBelongCycleList()){

//virtualUsage D4-1查标准数据详情(公共)  73904
      QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2040723_1_73904
if(circulationCollectionsRes!=null){
      queryStandardDataDetailComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2040721_1_73904
queryStandardDataDetailComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:2040722_1_73904
    }

    /*D4-1查标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataDetailComRespDto = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto)/*vcase invoke isSameApp*/;



if((queryStandardDataDetailComRespDto!= null&& queryStandardDataDetailComRespDto.getDataResultId() != null )) {
        //if(D4-1查当前内容当前周期当前有效的标准数据（用于判断需不需要进入计算）.数据结果ID  值不等于空 )  73905

ImplementCalcCurOrParentTargetDataComRespDto implementCalcCurOrParentTargetDataComRespDto = null;
    ImplementCalcCurOrParentTargetDataComReqDto implementCalcCurOrParentTargetDataComReqDto=new ImplementCalcCurOrParentTargetDataComReqDto();
  implementCalcCurOrParentTargetDataComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2040737_1_73906
if(circulationCollectionsRes!=null){
      implementCalcCurOrParentTargetDataComReqDto.setLastCycleCalcModelId(circulationCollectionsRes.getLastCycleCalcModelId());//SimpleFieldAssign//sourceId:2040725_1_73906
implementCalcCurOrParentTargetDataComReqDto.setProcessCycleCalcModelId(circulationCollectionsRes.getProcessCycleCalcModelId());//SimpleFieldAssign//sourceId:2040726_1_73906
implementCalcCurOrParentTargetDataComReqDto.setSubCycleCalcModelId(circulationCollectionsRes.getSubCycleCalcModelId());//SimpleFieldAssign//sourceId:2040727_1_73906
implementCalcCurOrParentTargetDataComReqDto.setMidCycleCalcModelId(circulationCollectionsRes.getMidCycleCalcModelId());//SimpleFieldAssign//sourceId:2040728_1_73906
implementCalcCurOrParentTargetDataComReqDto.setParentCycleCalcModelId(circulationCollectionsRes.getParentCycleCalcModelId());//SimpleFieldAssign//sourceId:2040729_1_73906
implementCalcCurOrParentTargetDataComReqDto.setPreUpdateCycleId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2040730_1_73906
implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2040731_1_73906
implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:2040732_1_73906
implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:2040733_1_73906
implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:2040734_1_73906
implementCalcCurOrParentTargetDataComReqDto.setIsLastCycle(circulationCollectionsRes.getIsLastCycle());//SimpleFieldAssign//sourceId:2040735_1_73906
implementCalcCurOrParentTargetDataComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040736_1_73906
    }
if(reqDto!=null){
      implementCalcCurOrParentTargetDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040738_1_73906
implementCalcCurOrParentTargetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040739_1_73906
implementCalcCurOrParentTargetDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040740_1_73906
    }

    /*D4执行MQ计算当前或祖先规划目标标准数据(公共)[10501]   */
    Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleId(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleStartTime(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleEndTime(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleTypeCode(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getIsLastCycle(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期是否末级周期不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getEvaluationTemplateId(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getSpaceId(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-创建于空间ID不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getEventBatchUpdateCode(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getCalcStartTime(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-计算开始时间不能为空",false);
Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getTargetScoreUnit(),"D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-目标得分单位不能为空",false);
      implementCalcCurOrParentTargetDataComRespDto = implementCalcCurOrParentTargetDataCom(implementCalcCurOrParentTargetDataComReqDto)/*vcase invoke 同服务,同domain*/;



      }
//virtualUsage M4-执行【循环结束】  73907
      //ModelCode: circulationEnd
        }

ImplementLoopCalcCyclesTargetDataComRespDto retData = new ImplementLoopCalcCyclesTargetDataComRespDto();





return retData;
  }
/**
   * D4执行MQ计算当前或兄弟内容异常场景(公共)[10504]
   * gen by moon at 3/6/2025, 10:14:40 PM
   */
  @Trace(operationName = "D4执行MQ计算当前或兄弟内容异常场景(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCalcCurOrBrothersTargetDataComRespDto implementCalcCurOrBrothersTargetDataCom(ImplementCalcCurOrBrothersTargetDataComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getDataCalcNormalAbnormal() !=null && reqDto.getDataCalcNormalAbnormal().equals("ABNORMAL_SCENE"))) {
        //if(D4执行MQ计算当前或兄弟内容异常场景(公共).数据计算正常与异常场景 等于 异常场景)  73908

QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = null;
    QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto=new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
  queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2040874_1_73910
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2040875_1_73910
if(reqDto!=null){
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2040877_1_73910
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2040876_1_73910
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040879_1_73910
    }

    /*D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)[9935]   */
    Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getCycleStartTime(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-周期开始时间不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaluationTemplateId(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjEntityId(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTypeCode(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象类型编码不能为空",false);
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementLoopCalcCyclesTargetDataComRespDto implementLoopCalcCyclesTargetDataComRespDto = null;
    if(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto !=null){
          ImplementLoopCalcCyclesTargetDataComReqDto implementLoopCalcCyclesTargetDataComReqDto=new ImplementLoopCalcCyclesTargetDataComReqDto();
  if(reqDto!=null){
      implementLoopCalcCyclesTargetDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040880_1_73911
implementLoopCalcCyclesTargetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040881_1_73911
implementLoopCalcCyclesTargetDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040882_1_73911
    }
if(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto!= null&&  queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList() !=null&& !CollectionUtil.isEmpty(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList())){
      implementLoopCalcCyclesTargetDataComReqDto.setTargetBelongCycleList(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList().stream().map(item -> BeanUtil.toBean(item, TargetBelongCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2040883_1_73911
    }

    /*D4执行MQ循环计算规划目标数据异常或修订场景(公共)[10503]   */
    Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto.getEventBatchUpdateCode(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto.getCalcStartTime(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-计算开始时间不能为空",false);
Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto.getTargetScoreUnit(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-目标得分单位不能为空",false);
      implementLoopCalcCyclesTargetDataComRespDto = implementLoopCalcCyclesTargetDataCom(implementLoopCalcCyclesTargetDataComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      }
else if((reqDto!= null&&  reqDto.getDataCalcNormalAbnormal() !=null && reqDto.getDataCalcNormalAbnormal().equals("REVISE_ABNORMAL_SCENE")&&reqDto!= null&& reqDto.getParentEvaObjTargetCycleId() != null )){
       //elseif((D4执行MQ计算当前或兄弟内容异常场景(公共).数据计算正常与异常场景 等于 修订异常场景 and D4执行MQ计算当前或兄弟内容异常场景(公共).上级被评对象目标周期标识 值不等于空 ))  73909

QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 = null;
    QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1=new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
  queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2040874_1_73912
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2040875_1_73912
if(reqDto!=null){
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2040878_1_73912
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2040876_1_73912
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040879_1_73912
    }

    /*D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)[9935]   */
    Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getCycleStartTime(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-周期开始时间不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaluationTemplateId(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaObjEntityId(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaObjTypeCode(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象类型编码不能为空",false);
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementLoopCalcCyclesTargetDataComRespDto implementLoopCalcCyclesTargetDataComRespDto_1 = null;
    if(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 !=null){
          ImplementLoopCalcCyclesTargetDataComReqDto implementLoopCalcCyclesTargetDataComReqDto_1=new ImplementLoopCalcCyclesTargetDataComReqDto();
  if(reqDto!=null){
      implementLoopCalcCyclesTargetDataComReqDto_1.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040880_1_73913
implementLoopCalcCyclesTargetDataComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040881_1_73913
implementLoopCalcCyclesTargetDataComReqDto_1.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040882_1_73913
    }
if(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2!= null&&  queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList() !=null&& !CollectionUtil.isEmpty(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList())){
      implementLoopCalcCyclesTargetDataComReqDto_1.setTargetBelongCycleList(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList().stream().map(item -> BeanUtil.toBean(item, TargetBelongCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2040883_1_73913
    }

    /*D4执行MQ循环计算规划目标数据异常或修订场景(公共)[10503]   */
    Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto_1.getEventBatchUpdateCode(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto_1.getCalcStartTime(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-计算开始时间不能为空",false);
Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto_1.getTargetScoreUnit(),"D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-目标得分单位不能为空",false);
      implementLoopCalcCyclesTargetDataComRespDto_1 = implementLoopCalcCyclesTargetDataCom(implementLoopCalcCyclesTargetDataComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
    }
ImplementCalcCurOrBrothersTargetDataComRespDto retData = new ImplementCalcCurOrBrothersTargetDataComRespDto();





return retData;
  }
/**
   * D4执行MQ计算父级内容向上规划目标数据(公共)[10505]
   * gen by moon at 3/6/2025, 10:14:53 PM
   */
  @Trace(operationName = "D4执行MQ计算父级内容向上规划目标数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCalcParentTargetDataComRespDto implementCalcParentTargetDataCom(ImplementCalcParentTargetDataComReqDto reqDto){


      //virtualUsage D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)  73914
      QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = null;
    QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto=new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
  queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2041189_1_73914
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2041190_1_73914
if(reqDto!=null){
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2041192_1_73914
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2041191_1_73914
queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2041193_1_73914
    }

    /*D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)[9935]   */
    Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTargetCycleCode(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getCycleStartTime(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-周期开始时间不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaluationTemplateId(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjEntityId(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTypeCode(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-主树被评对象类型编码不能为空",false);
      queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage M4执行目标归属周期【循环开始】  73915
      //ModelCode: circulationCollections
        for (com.wicket.okrapp.integration.dto.TargetBelongCycleDto circulationCollectionsRes: queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList()){

//virtualUsage D4-1查标准数据详情(公共)  73916
      QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2041208_1_73916
if(circulationCollectionsRes!=null){
      queryStandardDataDetailComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2041206_1_73916
queryStandardDataDetailComReqDto.setThemeContentId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2041207_1_73916
    }

    /*D4-1查标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4-1查标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataDetailComRespDto = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto)/*vcase invoke isSameApp*/;



if((queryStandardDataDetailComRespDto!= null&& queryStandardDataDetailComRespDto.getDataResultId() != null )) {
        //if(D4-1查标准数据详情(公共).数据结果ID  值不等于空 )  73917

ImplementCalcCurAndParentTargetDataComRespDto implementCalcCurAndParentTargetDataComRespDto = null;
    ImplementCalcCurAndParentTargetDataComReqDto implementCalcCurAndParentTargetDataComReqDto=new ImplementCalcCurAndParentTargetDataComReqDto();
  implementCalcCurAndParentTargetDataComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2041169_1_73918
implementCalcCurAndParentTargetDataComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2041170_1_73918
if(circulationCollectionsRes!=null){
      implementCalcCurAndParentTargetDataComReqDto.setPreUpdateCycleId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2041163_1_73918
implementCalcCurAndParentTargetDataComReqDto.setUpdateCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2041164_1_73918
implementCalcCurAndParentTargetDataComReqDto.setUpdateCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:2041165_1_73918
implementCalcCurAndParentTargetDataComReqDto.setUpdateCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:2041166_1_73918
implementCalcCurAndParentTargetDataComReqDto.setUpdateCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:2041167_1_73918
implementCalcCurAndParentTargetDataComReqDto.setIsLastCycle(circulationCollectionsRes.getIsLastCycle());//SimpleFieldAssign//sourceId:2041168_1_73918
implementCalcCurAndParentTargetDataComReqDto.setEvaObjTargetCycleCode(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2041171_1_73918
implementCalcCurAndParentTargetDataComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType()!=null?String.valueOf(circulationCollectionsRes.getParentSubMidCycleType()):"");//SimpleFieldAssign//sourceId:2041172_1_73918
implementCalcCurAndParentTargetDataComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2041173_1_73918
    }
if(reqDto!=null){
      implementCalcCurAndParentTargetDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2041174_1_73918
implementCalcCurAndParentTargetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2041175_1_73918
implementCalcCurAndParentTargetDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2041176_1_73918
    }

    /*D4执行MQ计算当前及祖先规划目标标准数据(公共)[10502]   */
    Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getUpdateCycleId(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getUpdateCycleStartTime(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getUpdateCycleEndTime(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getUpdateCycleTypeCode(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getIsLastCycle(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-更新周期是否末级周期不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getEvaObjEntityId(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getEvaObjTypeCode(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-主树被评对象类型编码不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getEvaObjTargetCycleCode(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getParentSubMidCycleType(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getEvaluationTemplateId(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getEventBatchUpdateCode(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getCalcStartTime(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-计算开始时间不能为空",false);
Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getTargetScoreUnit(),"D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-目标得分单位不能为空",false);
      implementCalcCurAndParentTargetDataComRespDto = implementCalcCurAndParentTargetDataCom(implementCalcCurAndParentTargetDataComReqDto)/*vcase invoke 同服务,同domain*/;



      }
//virtualUsage M4-执行【循环结束】  73919
      //ModelCode: circulationEnd
        }

ImplementCalcParentTargetDataComRespDto retData = new ImplementCalcParentTargetDataComRespDto();





return retData;
  }
/**
   * D4新增规划目标MQ队列数据(公共)[10491]
   * gen by moon at 3/10/2025, 8:12:31 PM
   */
  @Trace(operationName = "D4新增规划目标MQ队列数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddPlanTargetMqQueueComRespDto addPlanTargetMqQueueCom(AddPlanTargetMqQueueComReqDto reqDto){


      //步骤0: D2新增MQ队列数据(业务原子) - addMessageQueueDataBusCom
     AddMessageQueueDataBusComRespDto addMessageQueueDataBusComRespDto = null;
    AddMessageQueueDataBusComReqDto addMessageQueueDataBusComReqDto=new AddMessageQueueDataBusComReqDto();
  addMessageQueueDataBusComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2039656_1
addMessageQueueDataBusComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2039658_1
addMessageQueueDataBusComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2039660_1
addMessageQueueDataBusComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2039662_1
addMessageQueueDataBusComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2039664_1
addMessageQueueDataBusComReqDto.setCustomField6("isLastCycle");//CUSTOM_CONVENTION//sourceId:2039666_1
addMessageQueueDataBusComReqDto.setCustomField7("parentSubMidCycleType");//CUSTOM_CONVENTION//sourceId:2039668_1
addMessageQueueDataBusComReqDto.setCustomField8("evaObjTargetCycleCode");//CUSTOM_CONVENTION//sourceId:2039670_1
addMessageQueueDataBusComReqDto.setCustomField9("parentEvaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2039672_1
addMessageQueueDataBusComReqDto.setCustomField10("belongToContentId");//CUSTOM_CONVENTION//sourceId:2039674_1
addMessageQueueDataBusComReqDto.setCustomField11("evaObjEntityId");//CUSTOM_CONVENTION//sourceId:2039676_1
addMessageQueueDataBusComReqDto.setCustomField12("evaObjTypeCode");//CUSTOM_CONVENTION//sourceId:2039678_1
addMessageQueueDataBusComReqDto.setCustomField13("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2039680_1
addMessageQueueDataBusComReqDto.setCustomField14("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2039682_1
addMessageQueueDataBusComReqDto.setCustomField15("calcStartTime");//CUSTOM_CONVENTION//sourceId:2039684_1
addMessageQueueDataBusComReqDto.setCustomField16("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:2039686_1
addMessageQueueDataBusComReqDto.setCustomField17("dataCalcNormalAbnormal");//CUSTOM_CONVENTION//sourceId:2039688_1
addMessageQueueDataBusComReqDto.setCustomField18("operationInductionId");//CUSTOM_CONVENTION//sourceId:2042105_1
addMessageQueueDataBusComReqDto.setCustomField19("spaceId");//CUSTOM_CONVENTION//sourceId:2042107_1
addMessageQueueDataBusComReqDto.setCustomField20("appId");//CUSTOM_CONVENTION//sourceId:2042109_1
if(reqDto!=null){
      addMessageQueueDataBusComReqDto.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039716_1
addMessageQueueDataBusComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039717_1
addMessageQueueDataBusComReqDto.setCustomFieldValue1(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2039657_1
addMessageQueueDataBusComReqDto.setCustomFieldValue2(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2039659_1
addMessageQueueDataBusComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2039661_1
addMessageQueueDataBusComReqDto.setCustomFieldValue4(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2039663_1
addMessageQueueDataBusComReqDto.setCustomFieldValue5(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2039665_1
addMessageQueueDataBusComReqDto.setCustomFieldValue6(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2039667_1
addMessageQueueDataBusComReqDto.setCustomFieldValue7(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2039669_1
addMessageQueueDataBusComReqDto.setCustomFieldValue8(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2039671_1
addMessageQueueDataBusComReqDto.setCustomFieldValue9(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2039673_1
addMessageQueueDataBusComReqDto.setCustomFieldValue10(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2039675_1
addMessageQueueDataBusComReqDto.setCustomFieldValue11(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2039677_1
addMessageQueueDataBusComReqDto.setCustomFieldValue12(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2039679_1
addMessageQueueDataBusComReqDto.setCustomFieldValue13(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2039681_1
addMessageQueueDataBusComReqDto.setCustomFieldValue14(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2039683_1
addMessageQueueDataBusComReqDto.setCustomFieldValue15(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2039685_1
addMessageQueueDataBusComReqDto.setCustomFieldValue16(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2039687_1
addMessageQueueDataBusComReqDto.setCustomFieldValue17(reqDto.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2039689_1
addMessageQueueDataBusComReqDto.setCustomFieldValue18(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:2042106_1
addMessageQueueDataBusComReqDto.setCustomFieldValue19(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2042108_1
addMessageQueueDataBusComReqDto.setCustomFieldValue20(reqDto.getAppId());//SimpleFieldAssign//sourceId:2042110_1
    }

    /*D2新增MQ队列数据(业务原子)[10490]   */
    Assert.isNull(addMessageQueueDataBusComReqDto.getMqQueueName(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列名称不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getMqPrimaryId(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列唯一主键ID不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField1(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段1不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField2(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段2不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue2(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值2不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField3(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段3不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue3(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值3不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField4(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段4不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue4(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值4不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField5(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段5不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue5(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值5不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField6(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段6不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue6(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值6不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField7(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段7不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue7(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值7不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField8(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段8不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue8(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值8不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField9(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段9不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField10(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段10不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue10(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值10不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField11(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段11不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue11(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值11不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField12(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段12不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue12(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值12不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField13(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段13不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue13(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值13不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField14(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段14不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue14(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值14不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField15(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段15不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue15(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值15不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField16(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段16不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue16(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值16不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField17(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段17不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue17(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值17不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField18(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段18不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue18(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值18不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField19(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段19不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue19(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值19不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField20(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段20不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue20(),"D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值20不能为空",false);
      addMessageQueueDataBusComRespDto = fwCompBusinessAtomClient.addMessageQueueDataBusCom(addMessageQueueDataBusComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




AddPlanTargetMqQueueComRespDto retData = new AddPlanTargetMqQueueComRespDto();





return retData;
  }
/**
   * D4新增规划财务MQ队列数据(公共)[10492]
   * gen by moon at 3/10/2025, 8:12:39 PM
   */
  @Trace(operationName = "D4新增规划财务MQ队列数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddPlanFinanceMqQueueComRespDto addPlanFinanceMqQueueCom(AddPlanFinanceMqQueueComReqDto reqDto){


      //步骤0: D2新增MQ队列数据(业务原子) - addMessageQueueDataBusCom
     AddMessageQueueDataBusComRespDto addMessageQueueDataBusComRespDto = null;
    AddMessageQueueDataBusComReqDto addMessageQueueDataBusComReqDto=new AddMessageQueueDataBusComReqDto();
  addMessageQueueDataBusComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2039752_1
addMessageQueueDataBusComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2039754_1
addMessageQueueDataBusComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2039756_1
addMessageQueueDataBusComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2039758_1
addMessageQueueDataBusComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2039760_1
addMessageQueueDataBusComReqDto.setCustomField6("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2039762_1
addMessageQueueDataBusComReqDto.setCustomField7("accountContentCode");//CUSTOM_CONVENTION//sourceId:2039764_1
addMessageQueueDataBusComReqDto.setCustomField8("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:2039766_1
addMessageQueueDataBusComReqDto.setCustomField9("cycleMode");//CUSTOM_CONVENTION//sourceId:2039768_1
addMessageQueueDataBusComReqDto.setCustomField10(CommonFunctionHelper.getSessionUrl());//ACCESS_ADDRESS//sourceId:2039770_1
addMessageQueueDataBusComReqDto.setCustomField11("operationInductionId");//CUSTOM_CONVENTION//sourceId:2039772_1
addMessageQueueDataBusComReqDto.setCustomField12("spaceId");//CUSTOM_CONVENTION//sourceId:2039774_1
addMessageQueueDataBusComReqDto.setCustomField13("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2039776_1
addMessageQueueDataBusComReqDto.setCustomField14("calcStartTime");//CUSTOM_CONVENTION//sourceId:2039778_1
addMessageQueueDataBusComReqDto.setCustomField15("unit");//CUSTOM_CONVENTION//sourceId:2039780_1
addMessageQueueDataBusComReqDto.setCustomField16("appId");//CUSTOM_CONVENTION//sourceId:2042101_1
if(reqDto!=null){
      addMessageQueueDataBusComReqDto.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039812_1
addMessageQueueDataBusComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039813_1
addMessageQueueDataBusComReqDto.setCustomFieldValue1(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2039753_1
addMessageQueueDataBusComReqDto.setCustomFieldValue2(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2039755_1
addMessageQueueDataBusComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2039757_1
addMessageQueueDataBusComReqDto.setCustomFieldValue4(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2039759_1
addMessageQueueDataBusComReqDto.setCustomFieldValue5(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2039761_1
addMessageQueueDataBusComReqDto.setCustomFieldValue6(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2039763_1
addMessageQueueDataBusComReqDto.setCustomFieldValue7(reqDto.getAccountContentCode());//SimpleFieldAssign//sourceId:2039765_1
addMessageQueueDataBusComReqDto.setCustomFieldValue8(reqDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:2039767_1
addMessageQueueDataBusComReqDto.setCustomFieldValue9(reqDto.getCycleMode());//SimpleFieldAssign//sourceId:2039769_1
addMessageQueueDataBusComReqDto.setCustomFieldValue10(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2039771_1
addMessageQueueDataBusComReqDto.setCustomFieldValue11(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:2039773_1
addMessageQueueDataBusComReqDto.setCustomFieldValue12(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2039775_1
addMessageQueueDataBusComReqDto.setCustomFieldValue13(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2039777_1
addMessageQueueDataBusComReqDto.setCustomFieldValue14(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2039779_1
addMessageQueueDataBusComReqDto.setCustomFieldValue15(reqDto.getUnit());//SimpleFieldAssign//sourceId:2039781_1
addMessageQueueDataBusComReqDto.setCustomFieldValue16(reqDto.getAppId());//SimpleFieldAssign//sourceId:2042102_1
    }

    /*D2新增MQ队列数据(业务原子)[10490]   */
    Assert.isNull(addMessageQueueDataBusComReqDto.getMqQueueName(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列名称不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getMqPrimaryId(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列唯一主键ID不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField1(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段1不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField2(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段2不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue2(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值2不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField3(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段3不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue3(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值3不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField4(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段4不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue4(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值4不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField5(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段5不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue5(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值5不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField6(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段6不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue6(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值6不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField7(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段7不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue7(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值7不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField8(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段8不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue8(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值8不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField9(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段9不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue9(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值9不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField10(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段10不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue10(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值10不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField11(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段11不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue11(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值11不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField12(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段12不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue12(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值12不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField13(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段13不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue13(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值13不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField14(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段14不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue14(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值14不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField15(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段15不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue15(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值15不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField16(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段16不能为空",false);
Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue16(),"D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值16不能为空",false);
      addMessageQueueDataBusComRespDto = fwCompBusinessAtomClient.addMessageQueueDataBusCom(addMessageQueueDataBusComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




AddPlanFinanceMqQueueComRespDto retData = new AddPlanFinanceMqQueueComRespDto();





return retData;
  }
/**
   * D4查询规划目标MQ队列数据列表(公共)[10493]
   * gen by moon at 3/10/2025, 8:12:45 PM
   */
  @Trace(operationName = "D4查询规划目标MQ队列数据列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPlanTargetMqQueueListComRespDto queryPlanTargetMqQueueListCom(QueryPlanTargetMqQueueListComReqDto reqDto){


      QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto_1 =null;
//步骤0: D2查询MQ队列数据列表(业务原子) - queryMessageQueueDataListCom
     QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto = null;
    QueryMessageQueueDataListComReqDto queryMessageQueueDataListComReqDto=new QueryMessageQueueDataListComReqDto();
  queryMessageQueueDataListComReqDto.setMqQueueName("PLAN_TARGET_CALC_MQ_QUEUE");//sourceId:2040160_1
queryMessageQueueDataListComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2040040_1
queryMessageQueueDataListComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2040041_1
queryMessageQueueDataListComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2040042_1
queryMessageQueueDataListComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2040043_1
queryMessageQueueDataListComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2040044_1
queryMessageQueueDataListComReqDto.setCustomField6("isLastCycle");//CUSTOM_CONVENTION//sourceId:2040045_1
queryMessageQueueDataListComReqDto.setCustomField7("parentSubMidCycleType");//CUSTOM_CONVENTION//sourceId:2040046_1
queryMessageQueueDataListComReqDto.setCustomField8("evaObjTargetCycleCode");//CUSTOM_CONVENTION//sourceId:2040047_1
queryMessageQueueDataListComReqDto.setCustomField9("parentEvaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2040048_1
queryMessageQueueDataListComReqDto.setCustomField10("belongToContentId");//CUSTOM_CONVENTION//sourceId:2040049_1
queryMessageQueueDataListComReqDto.setCustomField11("evaObjEntityId");//CUSTOM_CONVENTION//sourceId:2040050_1
queryMessageQueueDataListComReqDto.setCustomField12("evaObjTypeCode");//CUSTOM_CONVENTION//sourceId:2040051_1
queryMessageQueueDataListComReqDto.setCustomField13("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2040052_1
queryMessageQueueDataListComReqDto.setCustomField14("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2040053_1
queryMessageQueueDataListComReqDto.setCustomField15("calcStartTime");//CUSTOM_CONVENTION//sourceId:2040054_1
queryMessageQueueDataListComReqDto.setCustomField16("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:2040055_1
queryMessageQueueDataListComReqDto.setCustomField17("dataCalcNormalAbnormal");//CUSTOM_CONVENTION//sourceId:2040056_1
queryMessageQueueDataListComReqDto.setCustomField18("operationInductionId");//CUSTOM_CONVENTION//sourceId:2042117_1
queryMessageQueueDataListComReqDto.setCustomField19("spaceId");//CUSTOM_CONVENTION//sourceId:2042118_1
queryMessageQueueDataListComReqDto.setCustomField20("appId");//CUSTOM_CONVENTION//sourceId:2042119_1
if(reqDto!=null){
      queryMessageQueueDataListComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040161_1
    }

    /*D2查询MQ队列数据列表(业务原子)[10495]   */
    Assert.isNull(queryMessageQueueDataListComReqDto.getMqQueueName(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列名称不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getMqPrimaryId(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列唯一主键ID不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField1(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段1不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField2(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段2不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField3(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段3不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField4(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段4不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField5(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段5不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField6(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段6不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField7(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段7不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField8(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段8不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField9(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段9不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField10(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段10不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField11(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段11不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField12(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段12不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField13(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段13不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField14(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段14不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField15(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段15不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField16(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段16不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField17(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段17不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField18(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段18不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField19(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段19不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField20(),"D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段20不能为空",false);
      queryMessageQueueDataListComRespDto = fwCompBusinessAtomClient.queryMessageQueueDataListCom(queryMessageQueueDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryMessageQueueDataListComRespDto_1 = queryMessageQueueDataListComRespDto;

QueryPlanTargetMqQueueListComRespDto retData = new QueryPlanTargetMqQueueListComRespDto();
  if(queryMessageQueueDataListComRespDto_1!=null){
      retData.setMqQueueName(queryMessageQueueDataListComRespDto_1.getMqQueueName());//SimpleFieldAssign//sourceId:2040091_1
retData.setMqPrimaryId(queryMessageQueueDataListComRespDto_1.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040092_1
retData.setMqQueueMinimum(queryMessageQueueDataListComRespDto_1.getMqQueueMinimum());//SimpleFieldAssign//sourceId:2040093_1
retData.setFieldDataList(//objList-to-objLists
        queryMessageQueueDataListComRespDto_1.getFieldDataList().stream().map(item -> {
      FieldDataDto elm = new FieldDataDto();
      if(item!=null){
      elm.setPreUpdateCycleId(item.getCustomField1());//SimpleFieldAssign//sourceId:431904_2
elm.setUpdateCycleId(item.getCustomField2());//SimpleFieldAssign//sourceId:431905_2
elm.setUpdateCycleStartTime(item.getCustomField3());//SimpleFieldAssign//sourceId:431906_2
elm.setUpdateCycleEndTime(item.getCustomField4());//SimpleFieldAssign//sourceId:431907_2
elm.setUpdateCycleTypeCode(item.getCustomField5());//SimpleFieldAssign//sourceId:431908_2
elm.setIsLastCycle(item.getCustomField6());//SimpleFieldAssign//sourceId:431909_2
elm.setParentSubMidCycleType(item.getCustomField7());//SimpleFieldAssign//sourceId:431910_2
elm.setEvaObjTargetCycleCode(item.getCustomField8());//SimpleFieldAssign//sourceId:431911_2
elm.setParentEvaObjTargetCycleId(item.getCustomField9());//SimpleFieldAssign//sourceId:431912_2
elm.setBelongToContentId(item.getCustomField10());//SimpleFieldAssign//sourceId:431913_2
elm.setEvaObjEntityId(item.getCustomField11());//SimpleFieldAssign//sourceId:431914_2
elm.setEvaObjTypeCode(item.getCustomField12());//SimpleFieldAssign//sourceId:431915_2
elm.setEvaluationTemplateId(item.getCustomField13());//SimpleFieldAssign//sourceId:431916_2
elm.setEventBatchUpdateCode(item.getCustomField14());//SimpleFieldAssign//sourceId:431917_2
elm.setCalcStartTime(item.getCustomField15());//SimpleFieldAssign//sourceId:431918_2
elm.setTargetScoreUnit(item.getCustomField16());//SimpleFieldAssign//sourceId:431919_2
elm.setDataCalcNormalAbnormal(item.getCustomField17());//SimpleFieldAssign//sourceId:431920_2
elm.setOperationInductionId(item.getCustomField18());//SimpleFieldAssign//sourceId:432615_2
elm.setSpaceId(item.getCustomField19());//SimpleFieldAssign//sourceId:432616_2
elm.setAppId(item.getCustomField20());//SimpleFieldAssign//sourceId:432617_2
elm.setMqDataPosition(item.getMqDataPosition());//SimpleFieldAssign//sourceId:432603_2
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2040094_1
    }




return retData;
  }
/**
   * D4查询规划财务MQ队列数据列表(公共)[10494]
   * gen by moon at 3/10/2025, 8:12:48 PM
   */
  @Trace(operationName = "D4查询规划财务MQ队列数据列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPlanFinanceMqQueueListComRespDto queryPlanFinanceMqQueueListCom(QueryPlanFinanceMqQueueListComReqDto reqDto){


      QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto_1 =null;
//步骤0: D2查询MQ队列数据列表(业务原子) - queryMessageQueueDataListCom
     QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto = null;
    QueryMessageQueueDataListComReqDto queryMessageQueueDataListComReqDto=new QueryMessageQueueDataListComReqDto();
  queryMessageQueueDataListComReqDto.setMqQueueName("FINANCIAL_CALC_MQ_QUEUE");//sourceId:2040157_1
queryMessageQueueDataListComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2040095_1
queryMessageQueueDataListComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2040096_1
queryMessageQueueDataListComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2040097_1
queryMessageQueueDataListComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2040098_1
queryMessageQueueDataListComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2040099_1
queryMessageQueueDataListComReqDto.setCustomField6("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2040100_1
queryMessageQueueDataListComReqDto.setCustomField7("accountContentCode");//CUSTOM_CONVENTION//sourceId:2040101_1
queryMessageQueueDataListComReqDto.setCustomField8("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:2040102_1
queryMessageQueueDataListComReqDto.setCustomField9("cycleMode");//CUSTOM_CONVENTION//sourceId:2040103_1
queryMessageQueueDataListComReqDto.setCustomField10("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2040104_1
queryMessageQueueDataListComReqDto.setCustomField11("operationInductionId");//CUSTOM_CONVENTION//sourceId:2040105_1
queryMessageQueueDataListComReqDto.setCustomField12("spaceId");//CUSTOM_CONVENTION//sourceId:2040106_1
queryMessageQueueDataListComReqDto.setCustomField13("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2040107_1
queryMessageQueueDataListComReqDto.setCustomField14("calcStartTime");//CUSTOM_CONVENTION//sourceId:2040108_1
queryMessageQueueDataListComReqDto.setCustomField15("unit");//CUSTOM_CONVENTION//sourceId:2040109_1
queryMessageQueueDataListComReqDto.setCustomField16("appId");//CUSTOM_CONVENTION//sourceId:2042120_1
if(reqDto!=null){
      queryMessageQueueDataListComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040158_1
    }

    /*D2查询MQ队列数据列表(业务原子)[10495]   */
    Assert.isNull(queryMessageQueueDataListComReqDto.getMqQueueName(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列名称不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getMqPrimaryId(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列唯一主键ID不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField1(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段1不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField2(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段2不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField3(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段3不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField4(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段4不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField5(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段5不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField6(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段6不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField7(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段7不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField8(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段8不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField9(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段9不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField10(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段10不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField11(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段11不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField12(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段12不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField13(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段13不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField14(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段14不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField15(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段15不能为空",false);
Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField16(),"D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段16不能为空",false);
      queryMessageQueueDataListComRespDto = fwCompBusinessAtomClient.queryMessageQueueDataListCom(queryMessageQueueDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryMessageQueueDataListComRespDto_1 = queryMessageQueueDataListComRespDto;

QueryPlanFinanceMqQueueListComRespDto retData = new QueryPlanFinanceMqQueueListComRespDto();
  if(queryMessageQueueDataListComRespDto_1!=null){
      retData.setMqQueueName(queryMessageQueueDataListComRespDto_1.getMqQueueName());//SimpleFieldAssign//sourceId:2040129_1
retData.setMqPrimaryId(queryMessageQueueDataListComRespDto_1.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040130_1
retData.setMqQueueMinimum(queryMessageQueueDataListComRespDto_1.getMqQueueMinimum());//SimpleFieldAssign//sourceId:2040131_1
retData.setFieldDataList(//objList-to-objLists
        queryMessageQueueDataListComRespDto_1.getFieldDataList().stream().map(item -> {
      FieldDataDto elm = new FieldDataDto();
      if(item!=null){
      elm.setPreUpdateCycleId(item.getCustomField1());//SimpleFieldAssign//sourceId:431964_2
elm.setUpdateCycleId(item.getCustomField2());//SimpleFieldAssign//sourceId:431965_2
elm.setUpdateCycleStartTime(item.getCustomField3());//SimpleFieldAssign//sourceId:431966_2
elm.setUpdateCycleEndTime(item.getCustomField4());//SimpleFieldAssign//sourceId:431967_2
elm.setUpdateCycleTypeCode(item.getCustomField5());//SimpleFieldAssign//sourceId:431968_2
elm.setEvaObjTargetCycleId(item.getCustomField6());//SimpleFieldAssign//sourceId:431969_2
elm.setAccountContentCode(item.getCustomField7());//SimpleFieldAssign//sourceId:431970_2
elm.setIsOpenFundsArrival(item.getCustomField8());//SimpleFieldAssign//sourceId:431971_2
elm.setCycleMode(item.getCustomField9());//SimpleFieldAssign//sourceId:431972_2
elm.setEvaluationTemplateId(item.getCustomField10());//SimpleFieldAssign//sourceId:431973_2
elm.setOperationInductionId(item.getCustomField11());//SimpleFieldAssign//sourceId:431974_2
elm.setSpaceId(item.getCustomField12());//SimpleFieldAssign//sourceId:431975_2
elm.setEventBatchUpdateCode(item.getCustomField13());//SimpleFieldAssign//sourceId:431976_2
elm.setCalcStartTime(item.getCustomField14());//SimpleFieldAssign//sourceId:431977_2
elm.setUnit(item.getCustomField15());//SimpleFieldAssign//sourceId:431978_2
elm.setAppId(item.getCustomField16());//SimpleFieldAssign//sourceId:432622_2
elm.setMqDataPosition(item.getMqDataPosition());//SimpleFieldAssign//sourceId:432606_2
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2040132_1
    }




return retData;
  }
/**
   * D4新增规划目标MQ-Redis队列数据(公共)[10524]
   * gen by moon at 4/20/2025, 4:29:37 PM
   */
  @Trace(operationName = "D4新增规划目标MQ-Redis队列数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddPlanTargetMqRedisQueueComRespDto addPlanTargetMqRedisQueueCom(AddPlanTargetMqRedisQueueComReqDto reqDto){


      //步骤0: M4-接收字段入参（计算使用） - addAcceptField
     //ModelCode: receptionService
        AddAcceptFieldRespDto receptionServiceRes = null;
    AddAcceptFieldReqDto receptionServiceReq=new AddAcceptFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2045804_1
receptionServiceReq.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2045809_1
receptionServiceReq.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2045810_1
    }

    /*M4-接收字段入参（计算使用）[6392]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D4新增规划目标MQ-Redis队列数据(公共)-M4-接收字段入参（计算使用）-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleStartTime(),"D4新增规划目标MQ-Redis队列数据(公共)-M4-接收字段入参（计算使用）-更新周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleEndTime(),"D4新增规划目标MQ-Redis队列数据(公共)-M4-接收字段入参（计算使用）-更新周期结束时间不能为空",false);
      receptionServiceRes = nbEvaCalc.addAcceptField(receptionServiceReq);




//步骤1: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
     ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
    ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto=new ImplementTimeFormatConversionComReqDto();
  if(reqDto!=null){
      implementTimeFormatConversionComReqDto.setComTxtField(reqDto.getUpdateCycleStartTime()!=null?String.valueOf(reqDto.getUpdateCycleStartTime()):"");//SimpleFieldAssign//sourceId:2045811_1
    }

    /*D2更新周期开始时间[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(),"D4新增规划目标MQ-Redis队列数据(公共)-D2更新周期开始时间-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto = fwCompInterfaceModeClient.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤2: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
     ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto_2 = null;
    ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto_1=new ImplementTimeFormatConversionComReqDto();
  if(reqDto!=null){
      implementTimeFormatConversionComReqDto_1.setComTxtField(reqDto.getUpdateCycleEndTime()!=null?String.valueOf(reqDto.getUpdateCycleEndTime()):"");//SimpleFieldAssign//sourceId:2045813_1
    }

    /*D2更新周期结束时间[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto_1.getComTxtField(),"D4新增规划目标MQ-Redis队列数据(公共)-D2更新周期结束时间-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto_2 = fwCompInterfaceModeClient.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤3: D2-新增redis业务数据对象（业务原子） - addRedisBusinessDataSetCom
     AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
    AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto=new AddRedisBusinessDataSetComReqDto();
  addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:2045919_1
addRedisBusinessDataSetComReqDto.setBusinessDataObject("PLAN_TARGET_CALC_MQ_QUEUE");//sourceId:2045816_1
addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:2045918_1
addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:2045815_1
addRedisBusinessDataSetComReqDto.setCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:2045817_1
addRedisBusinessDataSetComReqDto.setCustomField2("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2045819_1
addRedisBusinessDataSetComReqDto.setCustomField3("updateCycleId");//CUSTOM_CONVENTION//sourceId:2045821_1
addRedisBusinessDataSetComReqDto.setCustomField4("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2045823_1
addRedisBusinessDataSetComReqDto.setCustomField5("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2045825_1
addRedisBusinessDataSetComReqDto.setCustomField6("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2045827_1
addRedisBusinessDataSetComReqDto.setCustomField7("isLastCycle");//CUSTOM_CONVENTION//sourceId:2045829_1
addRedisBusinessDataSetComReqDto.setCustomField8("parentSubMidCycleType");//CUSTOM_CONVENTION//sourceId:2045831_1
addRedisBusinessDataSetComReqDto.setCustomField9("evaObjTargetCycleCode");//CUSTOM_CONVENTION//sourceId:2045833_1
addRedisBusinessDataSetComReqDto.setCustomField10("parentEvaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2045835_1
addRedisBusinessDataSetComReqDto.setCustomField11("belongToContentId");//CUSTOM_CONVENTION//sourceId:2045837_1
addRedisBusinessDataSetComReqDto.setCustomField12("evaObjEntityId");//CUSTOM_CONVENTION//sourceId:2045839_1
addRedisBusinessDataSetComReqDto.setCustomField13("evaObjTypeCode");//CUSTOM_CONVENTION//sourceId:2045841_1
addRedisBusinessDataSetComReqDto.setCustomField14("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2045843_1
addRedisBusinessDataSetComReqDto.setCustomField15("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2045845_1
addRedisBusinessDataSetComReqDto.setCustomField16("calcStartTime");//CUSTOM_CONVENTION//sourceId:2045847_1
addRedisBusinessDataSetComReqDto.setCustomField17("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:2045849_1
addRedisBusinessDataSetComReqDto.setCustomField18("dataCalcNormalAbnormal");//CUSTOM_CONVENTION//sourceId:2045851_1
addRedisBusinessDataSetComReqDto.setCustomField19("operationInductionId");//CUSTOM_CONVENTION//sourceId:2045853_1
addRedisBusinessDataSetComReqDto.setCustomField20("spaceId");//CUSTOM_CONVENTION//sourceId:2045855_1
addRedisBusinessDataSetComReqDto.setCustomField21("appId");//CUSTOM_CONVENTION//sourceId:2045857_1
if(reqDto!=null){
      addRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2045917_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getQueueNum());//SimpleFieldAssign//sourceId:2045818_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue2(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2045820_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2045822_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue4(reqDto.getUpdateCycleStartTime()!=null?String.valueOf(reqDto.getUpdateCycleStartTime()):"");//SimpleFieldAssign//sourceId:2045824_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue5(reqDto.getUpdateCycleEndTime()!=null?String.valueOf(reqDto.getUpdateCycleEndTime()):"");//SimpleFieldAssign//sourceId:2045826_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue6(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2045828_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue7(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2045830_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue8(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2045832_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue9(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2045834_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue10(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2045836_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue11(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2045838_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue12(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2045840_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue13(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2045842_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue14(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2045844_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue15(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2045846_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue16(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2045848_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue17(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2045850_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue18(reqDto.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2045852_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue19(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:2045854_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue20(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2045856_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue21(reqDto.getAppId());//SimpleFieldAssign//sourceId:2045858_1
    }

    /*D2-新增redis业务数据对象（业务原子）[8399]   */
    Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getDataObjectBatchCode(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-数据对象批次标识不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-是否删除redis历史数据不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值4不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值5不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段9不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值9不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField10(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段10不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField11(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段11不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue11(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值11不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField12(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段12不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue12(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值12不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField13(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段13不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue13(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值13不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField14(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段14不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue14(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值14不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField15(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段15不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue15(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值15不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField16(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段16不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue16(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值16不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField17(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段17不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue17(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值17不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField18(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段18不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue18(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值18不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField19(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段19不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue19(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值19不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField20(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段20不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue20(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值20不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField21(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段21不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue21(),"D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值21不能为空",false);
      addRedisBusinessDataSetComRespDto = fwCompBusinessAtomClient.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




AddPlanTargetMqRedisQueueComRespDto retData = new AddPlanTargetMqRedisQueueComRespDto();





return retData;
  }
/**
   * D4新增规划财务MQ-Redis队列数据(公共)[10525]
   * gen by moon at 4/20/2025, 4:29:55 PM
   */
  @Trace(operationName = "D4新增规划财务MQ-Redis队列数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddFinancialPlannMqRedisQueueComRespDto addFinancialPlannMqRedisQueueCom(AddFinancialPlannMqRedisQueueComReqDto reqDto){


      //步骤0: M4-执行接收字段（特殊方法） - implementReceiveField
     //ModelCode: receptionService
        ImplementReceiveFieldRespDto receptionServiceRes = null;
    ImplementReceiveFieldReqDto receptionServiceReq=new ImplementReceiveFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2046488_1
receptionServiceReq.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2046489_1
receptionServiceReq.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2046490_1
    }

    /*M4-执行接收字段（特殊方法）[2950]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D4新增规划财务MQ-Redis队列数据(公共)-M4-执行接收字段（特殊方法）-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleStartTime(),"D4新增规划财务MQ-Redis队列数据(公共)-M4-执行接收字段（特殊方法）-更新周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleEndTime(),"D4新增规划财务MQ-Redis队列数据(公共)-M4-执行接收字段（特殊方法）-更新周期结束时间不能为空",false);
      receptionServiceRes = nbEvaCalc.implementReceiveField(receptionServiceReq);




//步骤1: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
     ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
    ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto=new ImplementTimeFormatConversionComReqDto();
  if(reqDto!=null){
      implementTimeFormatConversionComReqDto.setComTxtField(reqDto.getUpdateCycleStartTime()!=null?String.valueOf(reqDto.getUpdateCycleStartTime()):"");//SimpleFieldAssign//sourceId:2046365_1
    }

    /*D2执行时间格式转换(公共)[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(),"D4新增规划财务MQ-Redis队列数据(公共)-D2执行时间格式转换(公共)-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto = fwCompInterfaceModeClient.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤2: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
     ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto_2 = null;
    ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto_1=new ImplementTimeFormatConversionComReqDto();
  if(reqDto!=null){
      implementTimeFormatConversionComReqDto_1.setComTxtField(reqDto.getUpdateCycleEndTime()!=null?String.valueOf(reqDto.getUpdateCycleEndTime()):"");//SimpleFieldAssign//sourceId:2046367_1
    }

    /*D2执行时间格式转换(公共)[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto_1.getComTxtField(),"D4新增规划财务MQ-Redis队列数据(公共)-D2执行时间格式转换(公共)-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto_2 = fwCompInterfaceModeClient.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤3: D2-新增redis业务数据对象（业务原子） - addRedisBusinessDataSetCom
     AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
    AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto=new AddRedisBusinessDataSetComReqDto();
  addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:2046473_1
addRedisBusinessDataSetComReqDto.setBusinessDataObject("FINANCIAL_CALC_MQ_QUEUE");//sourceId:2046370_1
addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:2046472_1
addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:2046369_1
addRedisBusinessDataSetComReqDto.setCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:2046371_1
addRedisBusinessDataSetComReqDto.setCustomField2("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2046373_1
addRedisBusinessDataSetComReqDto.setCustomField3("updateCycleId");//CUSTOM_CONVENTION//sourceId:2046375_1
addRedisBusinessDataSetComReqDto.setCustomField4("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2046377_1
addRedisBusinessDataSetComReqDto.setCustomField5("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2046379_1
addRedisBusinessDataSetComReqDto.setCustomField6("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2046381_1
addRedisBusinessDataSetComReqDto.setCustomField7("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2046383_1
addRedisBusinessDataSetComReqDto.setCustomField8("accountContentCode");//CUSTOM_CONVENTION//sourceId:2046385_1
addRedisBusinessDataSetComReqDto.setCustomField9("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:2046387_1
addRedisBusinessDataSetComReqDto.setCustomField10("cycleMode");//CUSTOM_CONVENTION//sourceId:2046389_1
addRedisBusinessDataSetComReqDto.setCustomField11("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2046391_1
addRedisBusinessDataSetComReqDto.setCustomField12("operationInductionId");//CUSTOM_CONVENTION//sourceId:2046393_1
addRedisBusinessDataSetComReqDto.setCustomField13("spaceId");//CUSTOM_CONVENTION//sourceId:2046395_1
addRedisBusinessDataSetComReqDto.setCustomField14("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2046397_1
addRedisBusinessDataSetComReqDto.setCustomField15("calcStartTime");//CUSTOM_CONVENTION//sourceId:2046399_1
addRedisBusinessDataSetComReqDto.setCustomField16("unit");//CUSTOM_CONVENTION//sourceId:2046401_1
addRedisBusinessDataSetComReqDto.setCustomField17("appId");//CUSTOM_CONVENTION//sourceId:2046403_1
if(reqDto!=null){
      addRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2046471_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getQueueNum());//SimpleFieldAssign//sourceId:2046372_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue2(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2046374_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2046376_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue4(reqDto.getUpdateCycleStartTime()!=null?String.valueOf(reqDto.getUpdateCycleStartTime()):"");//SimpleFieldAssign//sourceId:2046378_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue5(reqDto.getUpdateCycleEndTime()!=null?String.valueOf(reqDto.getUpdateCycleEndTime()):"");//SimpleFieldAssign//sourceId:2046380_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue6(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2046382_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue7(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2046384_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue8(reqDto.getAccountContentCode());//SimpleFieldAssign//sourceId:2046386_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue9(reqDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:2046388_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue10(reqDto.getCycleMode());//SimpleFieldAssign//sourceId:2046390_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue11(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2046392_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue12(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:2046394_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue13(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2046396_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue14(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2046398_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue15(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2046400_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue16(reqDto.getUnit());//SimpleFieldAssign//sourceId:2046402_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue17(reqDto.getAppId());//SimpleFieldAssign//sourceId:2046404_1
    }

    /*D2-新增redis业务数据对象（业务原子）[8399]   */
    Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段2不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值3不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值6不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值7不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值8不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值9不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue10(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值10不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue11(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值11不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue12(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值12不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue13(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值13不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue14(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值14不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue15(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值15不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue16(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值16不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue17(),"D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值17不能为空",false);
      addRedisBusinessDataSetComRespDto = fwCompBusinessAtomClient.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




AddFinancialPlannMqRedisQueueComRespDto retData = new AddFinancialPlannMqRedisQueueComRespDto();





return retData;
  }
  //
}
